v1alpha1

type AddonInfo struct {
	// Name specifies the name of the addon that will be used for the backup/restore purpose
	Name string `json:"name,omitempty"`

	// Tasks specifies a list of backup/restore tasks and their configuration parameters
	Tasks []TaskReference `json:"tasks,omitempty"`

	// ContainerRuntimeSettings specifies runtime settings for the backup/restore executor container
	// +optional
	ContainerRuntimeSettings *ofst.ContainerRuntimeSettings `json:"containerRuntimeSettings,omitempty"`

	// JobTemplate specifies runtime configurations for the backup/restore Job
	// +optional
	JobTemplate *ofst.PodTemplateSpec `json:"jobTemplate,omitempty"`
}

type AddonVolumeInfo struct {
	// Name specifies the name of the volume
	Name string `json:"name,omitempty"`

	// Source specifies the source of this volume.
	Source *apis.VolumeSource `json:"source,omitempty"`
}

type BackendReference struct {
	// Name provides an identifier for this storage.
	Name string `json:"name,omitempty"`

	// StorageRef refers to the CR that holds the information of a storage.
	// You can refer to the BackupStorage CR of a different namespace as long as it is allowed
	// by the `usagePolicy` of the BackupStorage.`
	StorageRef *kmapi.ObjectReference `json:"storageRef,omitempty"`

	// RetentionPolicy refers to a RetentionPolicy CRs which defines how to cleanup the old Snapshots.
	// This field is optional. If you don't provide this field, KubeStash will use the default RetentionPolicy for
	// the namespace. If there is no default RetentionPolicy for the namespace, then KubeStash will find a
	// RetentionPolicy from other namespaces that is allowed to use from the current namespace.
	// +optional
	RetentionPolicy *kmapi.ObjectReference `json:"retentionPolicy,omitempty"`
}

type BackendStatus struct {
	// Name indicates the backend name
	Name string `json:"name,omitempty"`

	// Ready indicates whether the respective BackupStorage is ready or not
	// +optional
	Ready *bool `json:"ready,omitempty"`

	// Storage indicates the status of the respective BackupStorage
	// +optional
	Storage *StorageStatus `json:"storage,omitempty"`

	// RetentionPolicy indicates the status of the respective RetentionPolicy
	// +optional
	RetentionPolicy *RetentionPolicyStatus `json:"retentionPolicy,omitempty"`
}

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

	Spec   BackupBatchSpec   `json:"spec,omitempty"`
	Status BackupBatchStatus `json:"status,omitempty"`
}

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

type BackupBatchSpec struct {
	// Backends specifies a list of storage references where the backed up data will be stored.
	// The respective BackupStorages can be in a different namespace than the BackupBatch.
	// However, it must be allowed by the `usagePolicy` of the BackupStorage to refer from this namespace.
	//
	// This field is optional, if you don't provide any backend here, KubeStash will use the default BackupStorage for the namespace.
	// If a default BackupStorage does not exist in the same namespace, then KubeStash will look for a default BackupStorage
	// in other namespaces that allows using it from the BackupBatch namespace.
	// +optional
	Backends []BackendReference `json:"backends,omitempty"`

	// Targets specifies a list of targets that are subject to backup.
	Targets []TargetReference `json:"targets,omitempty"`

	// Session defines a list of session configurations that specifies when and how to take backup.
	Sessions []BatchSession `json:"sessions,omitempty"`

	// Paused indicates that the BackupBatch has been paused from taking backup. Default value is 'false'.
	// If you set `paused` field to `true`, KubeStash will suspend the respective backup triggering CronJob and
	// skip processing any further events for this BackupBatch.
	// +optional
	Paused bool `json:"paused,omitempty"`
}

type BackupBatchStatus struct {
	// +optional
	OffshootStatus `json:",inline"`

	// Phase represents the current state of the Backup Invoker.
	// +optional
	Phase BackupInvokerPhase `json:"phase,omitempty"`

	// Targets specifies whether the backup targets exist or not
	// +optional
	Targets []ResourceFoundStatus `json:"targets,omitempty"`

	// Conditions represents list of conditions regarding this BackupConfiguration
	// +optional
	Conditions []kmapi.Condition `json:"conditions,omitempty"`
}

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

	Spec BackupBlueprintSpec `json:"spec,omitempty"`
}

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

type BackupBlueprintSpec struct {
	// BackupConfigurationTemplate Specifies the BackupConfiguration that will be created by BackupBlueprint.
	BackupConfigurationTemplate *BackupConfigurationTemplate `json:"backupConfigurationTemplate,omitempty"`

	// Subjects specify a list of subject to which this BackupBlueprint is applicable. KubeStash will start watcher for these resources.
	// Multiple BackupBlueprints can have common subject. The watcher will find the appropriate blueprint from its annotations.
	Subjects []metav1.TypeMeta `json:"subjects,omitempty"`

	// UsagePolicy specifies a policy of how this BackupBlueprint will be used. For example,
	// you can use `allowedNamespaces` policy to restrict the usage of this BackupBlueprint to particular namespaces.
	// This field is optional. If you don't provide the usagePolicy, then it can be used only from the current namespace.
	// +optional
	UsagePolicy *apis.UsagePolicy `json:"usagePolicy,omitempty"`
}

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

	Spec   BackupConfigurationSpec   `json:"spec,omitempty"`
	Status BackupConfigurationStatus `json:"status,omitempty"`
}

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

type BackupConfigurationSpec struct {
	// Target refers to the target of backup. The target must be in the same namespace as the BackupConfiguration.
	Target *kmapi.TypedObjectReference `json:"target,omitempty"`

	// Backends specifies a list of storage references where the backed up data will be stored.
	// The respective BackupStorages can be in a different namespace than the BackupConfiguration.
	// However, it must be allowed by the `usagePolicy` of the BackupStorage to refer from this namespace.
	//
	// This field is optional, if you don't provide any backend here, KubeStash will use the default BackupStorage for the namespace.
	// If a default BackupStorage does not exist in the same namespace, then KubeStash will look for a default BackupStorage
	// in other namespaces that allows using it from the BackupConfiguration namespace.
	// +optional
	Backends []BackendReference `json:"backends,omitempty"`

	// Sessions defines a list of session configuration that specifies when and how to take backup.
	Sessions []Session `json:"sessions,omitempty"`

	// Paused indicates that the BackupConfiguration has been paused from taking backup. Default value is 'false'.
	// If you set `paused` field to `true`, KubeStash will suspend the respective backup triggering CronJob and
	// skip processing any further events for this BackupConfiguration.
	// +optional
	Paused bool `json:"paused,omitempty"`
}

type BackupConfigurationStatus struct {
	// +optional
	OffshootStatus `json:",inline"`

	// Phase represents the current state of the Backup Invoker.
	// +optional
	Phase BackupInvokerPhase `json:"phase,omitempty"`

	// TargetFound specifies whether the backup target exist or not
	// +optional
	TargetFound *bool `json:"targetFound,omitempty"`

	// Conditions represents list of conditions regarding this BackupConfiguration
	// +optional
	Conditions []kmapi.Condition `json:"conditions,omitempty"`
}

type BackupConfigurationTemplate struct {
	// Namespace specifies the namespace of the BackupConfiguration.
	// The field is optional. If you don't provide the namespace, then BackupConfiguration will be created in the BackupBlueprint namespace.
	// +optional
	Namespace string `json:"namespace,omitempty"`

	// Backends specifies a list of storage references where the backed up data will be stored.
	// The respective BackupStorages can be in a different namespace than the BackupConfiguration.
	// However, it must be allowed by the `usagePolicy` of the BackupStorage to refer from this namespace.
	//
	// This field is optional, if you don't provide any backend here, KubeStash will use the default BackupStorage for the namespace.
	// If a default BackupStorage does not exist in the same namespace, then KubeStash will look for a default BackupStorage
	// in other namespaces that allows using it from the BackupConfiguration namespace.
	// +optional
	Backends []BackendReference `json:"backends,omitempty"`

	// Sessions specifies a list of session template for backup. You can use custom variables
	// in your template then provide the variable value through annotations.
	Sessions []Session `json:"sessions,omitempty"`

	// DeletionPolicy specifies whether the BackupConfiguration will be deleted on BackupBlueprint deletion
	// This field is optional, if you don't provide deletionPolicy, then BackupConfiguration will not be deleted on BackupBlueprint deletion
	// +optional
	DeletionPolicy DeletionPolicy `json:"deletionPolicy,omitempty"`
}

type BackupHooks struct {
	// PreBackup specifies a list of hooks that will be executed before backup
	// +optional
	PreBackup []HookInfo `json:"preBackup,omitempty"`

	// PostBackup specifies a list of hooks that will be executed after backup
	// +optional
	PostBackup []HookInfo `json:"postBackup,omitempty"`
}

type BackupInvokerPhase string

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

	Spec   BackupSessionSpec   `json:"spec,omitempty"`
	Status BackupSessionStatus `json:"status,omitempty"`
}

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

type BackupSessionPhase string

type BackupSessionSpec struct {
	// Invoker points to the respective BackupConfiguration or BackupBatch
	// which is responsible for triggering this backup.
	Invoker *core.TypedLocalObjectReference `json:"invoker,omitempty"`

	// Session specifies the name of the session that triggered this backup
	Session string `json:"session,omitempty"`

	// RetryLeft specifies number of retry attempts left for the session.
	// If this set to non-zero, KubeStash will create a new BackupSession if the current one fails.
	// +optional
	RetryLeft int32 `json:"retryLeft,omitempty"`
}

type BackupSessionStatus struct {
	// Phase represents the current state of the backup process.
	// +optional
	Phase BackupSessionPhase `json:"phase,omitempty"`

	// Duration specifies the time required to complete the backup process
	// +optional
	Duration string `json:"duration,omitempty"`

	// Deadline specifies the deadline of backup. BackupSession will be
	// considered Failed if backup does not complete within this deadline
	// +optional
	Deadline *metav1.Time `json:"sessionDeadline,omitempty"`

	// Snapshots specifies the Snapshots status
	// +optional
	Snapshots []SnapshotStatus `json:"snapshots,omitempty"`

	// Hooks represents the hook execution status
	// +optional
	Hooks HookStatus `json:"hooks,omitempty"`

	// Verifications specifies the backup verification status
	// +optional
	Verifications []VerificationStatus `json:"verifications,omitempty"`

	// RetentionPolices specifies whether the retention policies were properly applied on the repositories or not
	// +optional
	RetentionPolicies []RetentionPolicyApplyStatus `json:"retentionPolicy,omitempty"`

	// Retried specifies whether this session was retried or not.
	// This field will exist only if the `retryConfig` has been set in the respective backup invoker.
	// +optional
	Retried *bool `json:"retried,omitempty"`

	// NextRetry specifies the time when KubeStash should retry the current failed backup.
	// This field will exist only if the `retryConfig` has been set in the respective backup invoker.
	// +optional
	NextRetry *metav1.Time `json:"nextRetry,omitempty"`

	// Conditions represents list of conditions regarding this BackupSession
	// +optional
	Conditions []kmapi.Condition `json:"conditions,omitempty"`
}

type BackupVerificationPhase string

type BatchSession struct {
	*SessionConfig `json:",inline"`

	// Targets specifies a list of target backup specification.
	Targets []TargetBackupSpec `json:"targets,omitempty"`
}

type ComponentRestoreStatus struct {
	// Phase represents the restore phase of the component
	// +optional
	Phase RestorePhase `json:"phase,omitempty"`

	// Duration specifies the total time taken to complete the restore process for this component
	// +optional
	Duration string `json:"duration,omitempty"`

	// Error specifies the reason in case of restore failure for the component
	// +optional
	Error string `json:"error,omitempty"`
}

type DeletionPolicy string

type FailurePolicy string

type FunctionHookExecutorSpec struct {
	// Name indicate the name of the Function that contains the container definition for executing the hook logic
	Name string `json:"name,omitempty"`

	// EnvVariables specifies a list of environment variables that will be passed to the executor container
	// +optional
	EnvVariables []core.EnvVar `json:"env,omitempty"`

	// VolumeMounts specifies the volumes mounts for the executor container
	// +optional
	VolumeMounts []core.VolumeMount `json:"volumeMounts,omitempty"`

	// Volumes specifies the volumes that will be mounted in the executor container
	// +optional
	Volumes []ofst.Volume `json:"volumes,omitempty"`
}

type HookExecutionPhase string

type HookExecutionPolicy string

type HookExecutionStatus struct {
	// Name indicates the name of the hook whose status is being shown here.
	Name string `json:"name,omitempty"`

	// Phase represents the hook execution phase
	// +optional
	Phase HookExecutionPhase `json:"phase,omitempty"`
}

type HookExecutor struct {
	// Type indicate the types of entity that will execute the hook.
	// Valid values are:
	// - "Function": KubeStash will create a job with the provided information in `function` section. The job will execute the hook.
	// - "Pod": KubeStash will select the pod that matches the selector provided in `pod` section. This pod(s) will execute the hook.
	// - "Operator": KubeStash operator itself will execute the hook.
	Type HookExecutorType `json:"type,omitempty"`

	// Function specifies the function information which will be used to create the hook executor job.
	// +optional
	Function *FunctionHookExecutorSpec `json:"function,omitempty"`

	// Pod specifies the criteria to use to select the hook executor pods
	// +optional
	Pod *PodHookExecutorSpec `json:"pod,omitempty"`
}

type HookExecutorType string

type HookInfo struct {
	// Name specifies a name for the hook
	Name string `json:"name,omitempty"`

	// HookTemplate points to a HookTemplate CR that will be used to execute the hook.
	// You can refer to a HookTemplate from other namespaces as long as your current
	// namespace is allowed by the `usagePolicy` in the respective HookTemplate.
	HookTemplate *kmapi.ObjectReference `json:"hookTemplate,omitempty"`

	// Params specifies parameters for the hook. You must provide the parameter in the HookTemplates desired structure.
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	Params *runtime.RawExtension `json:"params,omitempty"`

	// MaxRetry specifies how many times KubeStash should retry the hook execution in case of failure.
	// The default value of this field is 0 which means no retry.
	// +kubebuilder:validation:Minimum=0
	// +optional
	MaxRetry int32 `json:"maxRetry,omitempty"`

	// Timeout specifies a duration in seconds that KubeStash should wait for the hook execution to be completed.
	// If the hook execution does not finish within this time period, KubeStash will consider this hook execution as failure.
	// Then, it will be re-tried according to MaxRetry policy.
	// +optional
	Timeout *metav1.Duration `json:"timeout,omitempty"`

	// ExecutionPolicy specifies when to execute the hook.
	// Valid values are:
	// - "Always": KubeStash will execute this hook no matter the backup/restore failed. This is the default execution policy.
	// - "OnSuccess": KubeStash will execute this hook only if the backup/restore has succeeded.
	// - "OnFailure": KubeStash will execute this hook only if the backup/restore has failed.
	// +kubebuilder:default=Always
	// +optional
	ExecutionPolicy HookExecutionPolicy `json:"executionPolicy,omitempty"`

	// Variables specifies a list of variables and their sources that will be used to resolve the HookTemplate.
	// +optional
	Variables []core.EnvVar `json:"variables,omitempty"`

	// Volumes indicates the list of volumes of targeted application that should be mounted on the hook executor.
	// Use this field only for `Function` type hook executor.
	// +optional
	Volumes []ofst.Volume `json:"volumes,omitempty"`

	// VolumeMounts specifies the mount for the volumes specified in `Volumes` section
	// Use this field only for `Function` type hook executor.
	// +optional
	VolumeMounts []core.VolumeMount `json:"volumeMounts,omitempty"`

	// RuntimeSettings specifies runtime configurations for the hook executor Job.
	// Use this field only for `Function` type hook executor.
	// +optional
	RuntimeSettings *ofst.RuntimeSettings `json:"runtimeSettings,omitempty"`
}

type HookStatus struct {
	// PreHooks represents the pre-restore hook execution status
	// +optional
	PreHooks []HookExecutionStatus `json:"preHooks,omitempty"`

	// PostHooks represents the post-restore hook execution status
	// +optional
	PostHooks []HookExecutionStatus `json:"postHooks,omitempty"`
}

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

	Spec HookTemplateSpec `json:"spec,omitempty"`
}

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

type HookTemplateSpec struct {
	// UsagePolicy specifies a policy of how this HookTemplate will be used. For example,
	// you can use `allowedNamespaces` policy to restrict the usage of this HookTemplate to particular namespaces.
	//
	// This field is optional. If you don't provide the usagePolicy, then it can be used only from the current namespace.
	// +optional
	UsagePolicy *apis.UsagePolicy `json:"usagePolicy,omitempty"`

	// Params defines a list of parameters that is used by the HookTemplate to execute its logic.
	// +optional
	Params []apis.ParameterDefinition `json:"params,omitempty"`

	// Action specifies the operation that is performed by this HookTemplate
	// Valid values are:
	// - "exec": Execute command in a shell
	// - "httpGet": Do an HTTP GET request
	// - "httpPost": Do an HTTP POST request
	// - "tcpSocket": Check if a TCP socket open or not
	Action *prober.Handler `json:"action,omitempty"`

	// Executor specifies the entity where the hook will be executed.
	Executor *HookExecutor `json:"executor,omitempty"`
}

type JobTemplate struct {
	// Specifies the maximum desired number of pods the job should
	// run at any given time. The actual number of pods running in steady state will
	// be less than this number when ((.spec.completions - .status.successful) < .spec.parallelism),
	// i.e. when the work left to do is less than max parallelism.
	// More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/
	// +optional
	Parallelism *int32 `json:"parallelism,omitempty"`

	// Specifies the desired number of successfully finished pods the
	// job should be run with.  Setting to nil means that the success of any
	// pod signals the success of all pods, and allows parallelism to have any positive
	// value.  Setting to 1 means that parallelism is limited to 1 and the success of that
	// pod signals the success of the job.
	// More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/
	// +optional
	Completions *int32 `json:"completions,omitempty"`

	// Specifies the duration in seconds relative to the startTime that the job
	// may be continuously active before the system tries to terminate it; value
	// must be positive integer. If a Job is suspended (at creation or through an
	// update), this timer will effectively be stopped and reset when the Job is
	// resumed again.
	// +optional
	ActiveDeadlineSeconds *int64 `json:"activeDeadlineSeconds,omitempty"`

	// Specifies the number of retries before marking this job failed.
	// Defaults to 6
	// +optional
	BackoffLimit *int32 `json:"backoffLimit,omitempty"`

	// Describes the pod that will be created when executing a job.
	// +optional
	Template ofst.PodTemplateSpec `json:"template"`

	// ttlSecondsAfterFinished limits the lifetime of a Job that has finished
	// execution (either Complete or Failed). If this field is set,
	// ttlSecondsAfterFinished after the Job finishes, it is eligible to be
	// automatically deleted. When the Job is being deleted, its lifecycle
	// guarantees (e.g. finalizers) will be honored. If this field is unset,
	// the Job won't be automatically deleted. If this field is set to zero,
	// the Job becomes eligible to be deleted immediately after it finishes.
	// This field is alpha-level and is only honored by servers that enable the
	// TTLAfterFinished feature.
	// +optional
	TTLSecondsAfterFinished *int32 `json:"ttlSecondsAfterFinished,omitempty"`

	// CompletionMode specifies how Pod completions are tracked. It can be
	// `NonIndexed` (default) or `Indexed`.
	//
	// `NonIndexed` means that the Job is considered complete when there have
	// been .spec.completions successfully completed Pods. Each Pod completion is
	// homologous to each other.
	//
	// `Indexed` means that the Pods of a
	// Job get an associated completion index from 0 to (.spec.completions - 1),
	// available in the annotation batch.kubernetes.io/job-completion-index.
	// The Job is considered complete when there is one successfully completed Pod
	// for each index.
	// When value is `Indexed`, .spec.completions must be specified and
	// `.spec.parallelism` must be less than or equal to 10^5.
	//
	// This field is alpha-level and is only honored by servers that enable the
	// IndexedJob feature gate. More completion modes can be added in the future.
	// If the Job controller observes a mode that it doesn't recognize, the
	// controller skips updates for the Job.
	// +optional
	CompletionMode *batchv1.CompletionMode `json:"completionMode,omitempty"`

	// Suspend specifies whether the Job controller should create Pods or not. If
	// a Job is created with suspend set to true, no Pods are created by the Job
	// controller. If a Job is suspended after creation (i.e. the flag goes from
	// false to true), the Job controller will delete all active Pods associated
	// with this Job. Users must design their workload to gracefully handle this.
	// Suspending a Job will reset the StartTime field of the Job, effectively
	// resetting the ActiveDeadlineSeconds timer too. This is an alpha field and
	// requires the SuspendJob feature gate to be enabled; otherwise this field
	// may not be set to true. Defaults to false.
	// +optional
	Suspend *bool `json:"suspend,omitempty"`
}

type KubeDBManifestOptions struct {
	// DB specifies whether to restore the DB manifest or not
	// +optional
	DB bool `json:"db,omitempty"`

	// DBName specifies the new name of the DB yaml after restore
	// +optional
	DBName string `json:"dbName,omitempty"`

	// AuthSecret specifies whether to restore the AuthSecret manifest or not
	// +optional
	AuthSecret bool `json:"authSecret,omitempty"`

	// AuthSecretName specifies new name of the AuthSecret yaml after restore
	// +optional
	AuthSecretName string `json:"authSecretName,omitempty"`

	// ConfigSecret specifies whether to restore the ConfigSecret manifest or not
	// +optional
	ConfigSecret bool `json:"configSecret,omitempty"`

	// ConfigSecretName specifies new name of the ConfigSecret yaml after restore
	// +optional
	ConfigSecretName string `json:"configSecretName,omitempty"`

	// IssuerRefName specifies new name of the IssuerRef after restore
	// +optional
	IssuerRefName string `json:"issuerRefName,omitempty"`
}

type ManifestRestoreOptions struct {
	// RestoreNamespace specifies the Namespace where the restored files will be applied
	//+optional
	RestoreNamespace string `json:"restoreNamespace,omitempty"`

	// MongoDB specifies the options for selecting particular MongoDB components to restore in manifest restore
	// +optional
	MongoDB *KubeDBManifestOptions `json:"mongoDB,omitempty"`

	// Postgres specifies the options for selecting particular Postgres components to restore in manifest restore
	// +optional
	Postgres *KubeDBManifestOptions `json:"postgres,omitempty"`

	// MySQL specifies the options for selecting particular MySQL components to restore in manifest restore
	// +optional
	MySQL *KubeDBManifestOptions `json:"mySQL,omitempty"`

	// MariaDB specifies the options for selecting particular MariaDB components to restore in manifest restore
	// +optional
	MariaDB *KubeDBManifestOptions `json:"mariaDB,omitempty"`
}

type OffshootStatus struct {
	// Backends specifies whether the backends exist or not
	// +optional
	Backends []BackendStatus `json:"backends,omitempty"`

	// Repositories specifies whether the repositories have been successfully initialized or not
	// +optional
	Repositories []RepoStatus `json:"repositories,omitempty"`

	// Dependencies specifies whether the objects required by this BackupConfiguration exist or not
	// +optional
	Dependencies []ResourceFoundStatus `json:"dependencies,omitempty"`

	// Sessions specifies status of the session specific resources
	// +optional
	Sessions []SessionStatus `json:"sessions,omitempty"`
}

type PITR struct {
	// TargetTime specifies the desired date and time at which you want to roll back your application data
	TargetTime *metav1.Time `json:"targetTime,omitempty"`

	// Exclusive specifies whether to exclude the Snapshot that falls in the exact time specified
	// in the `targetTime` field. By default, KubeStash will select the Snapshot that fall in the exact time.
	// +optional
	Exclusive bool `json:"exclusive,omitempty"`
}

type PodHookExecutionStrategy string

type PodHookExecutorSpec struct {
	// Selector specifies list of key value pair that will be used as label selector to select the desired pods.
	// You can use comma to separate multiple labels (i.e. "app=my-app,env=prod")
	Selector string `json:"selector,omitempty"`

	// Owner specifies a template for owner reference that will be used to filter the selected pods.
	// +optional
	Owner *metav1.OwnerReference `json:"owner,omitempty"`

	// Strategy specifies what should be the behavior when multiple pods are selected
	// Valid values are:
	// - "ExecuteOnOne": Execute hook on only one of the selected pods. This is default behavior
	// - "ExecuteOnAll": Execute hook on all the selected pods.
	// +kubebuilder:default=ExecuteOnOne
	Strategy PodHookExecutionStrategy `json:"strategy,omitempty"`
}

type RepoStatus struct {
	// Name indicate the name of the Repository
	Name string `json:"name,omitempty"`

	// Ready indicates whether the respective Repository is ready or not
	// +optional
	Phase v1alpha1.RepositoryPhase `json:"phase,omitempty"`

	// Reason specifies the error messages found while ensuring the respective Repository
	// +optional
	Reason string `json:"reason,omitempty"`
}

type RepositoryInfo struct {
	// Name specifies the name of the Repository
	Name string `json:"name,omitempty"`

	// Backend specifies the name of the backend where this repository will be initialized.
	// This should point to a backend name specified in `.spec.backends` section.
	// For using a default backend, keep this field empty.
	// +optional
	Backend string `json:"backend,omitempty"`

	// Directory specifies the path inside the backend where the backed up data will be stored.
	Directory string `json:"directory,omitempty"`

	// EncryptionSecret refers to the Secret containing the encryption key which will be used to encode/decode the backed up dta.
	// You can refer to a Secret of a different namespace.
	// If you don't provide the namespace field, KubeStash will look for the Secret in the same namespace as the BackupConfiguration / BackupBatch.
	EncryptionSecret *kmapi.ObjectReference `json:"encryptionSecret,omitempty"`

	// DeletionPolicy specifies what to do when you delete a Repository CR.
	// +optional
	DeletionPolicy v1alpha1.DeletionPolicy `json:"deletionPolicy,omitempty"`
}

type ResourceFoundStatus struct {
	kmapi.TypedObjectReference `json:",inline"`
	// Found indicates whether the resource was found or not
	Found *bool `json:"found,omitempty"`
}

type RestoreDataSource struct {
	// Namespace specifies the namespace of the DataSource (i.e. Repository, Snapshot).
	Namespace string `json:"namespace,omitempty"`

	// Repository points to the Repository name from which the data will be restored
	Repository string `json:"repository,omitempty"`

	// Snapshot specifies the Snapshot name that will be restored.
	// If you want to use Point-In-Time recovery option, don't specify this field. Specify `pitr` field instead.
	// +optional
	Snapshot string `json:"snapshot,omitempty"`

	// PITR stands for Point-In-Time Recovery. You can provide a target time instead of specifying a particular Snapshot.
	// KubeStash will automatically find the latest Snapshot that satisfies the targeted time and restore it.
	// +optional
	PITR *PITR `json:"pitr,omitempty"`

	// Components specifies the components that will be restored. If you keep this field empty, then all
	// the components that were backed up in the desired Snapshot will be restored.
	// +optional
	Components []string `json:"components,omitempty"`

	// EncryptionSecret refers to the Secret containing the encryption key which will be used to encode/decode the backed up data.
	// You can refer to a Secret of a different namespace.
	// If you don't provide the namespace field, KubeStash will look for the Secret in the same namespace as the RestoreSession.
	// +optional
	EncryptionSecret *kmapi.ObjectReference `json:"encryptionSecret,omitempty"`
}

type RestoreHooks struct {
	// PreRestore specifies a list of hooks that will be executed before restore
	// +optional
	PreRestore []HookInfo `json:"preRestore,omitempty"`

	// PostRestore specifies a list of hooks that will be executed after restore
	// +optional
	PostRestore []HookInfo `json:"postRestore,omitempty"`
}

type RestorePhase string

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

	Spec   RestoreSessionSpec   `json:"spec,omitempty"`
	Status RestoreSessionStatus `json:"status,omitempty"`
}

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

type RestoreSessionSpec struct {
	// Target indicates the target application where the data will be restored.
	// The target must be in the same namespace as the RestoreSession CR.
	// +optional
	Target *kmapi.TypedObjectReference `json:"target,omitempty"`

	// DataSource specifies the information about the data that will be restored
	DataSource *RestoreDataSource `json:"dataSource,omitempty"`

	// Addon specifies addon configuration that will be used to restore the target.
	Addon *AddonInfo `json:"addon,omitempty"`

	// Hooks specifies the restore hooks that should be executed before and/or after the restore.
	// +optional
	Hooks *RestoreHooks `json:"hooks,omitempty"`

	// Timeout specifies a duration that KubeStash should wait for the session execution to be completed.
	// If the session execution does not finish within this time period, KubeStash will consider this session as a failure.
	// +optional
	Timeout *metav1.Duration `json:"timeout,omitempty"`

	// ManifestOptions provide options to select particular manifest object to restore
	// +optional
	ManifestOptions *ManifestRestoreOptions `json:"manifestOptions,omitempty"`
}

type RestoreSessionStatus struct {
	// Phase represents the current state of the restore process
	// +optional
	Phase RestorePhase `json:"phase,omitempty"`

	// TargetFound specifies whether the restore target exist or not
	// +optional
	TargetFound *bool `json:"targetFound,omitempty"`

	// Duration specifies the total time taken to complete the restore process
	// +optional
	Duration string `json:"duration,omitempty"`

	// Deadline specifies a timestamp till this session is valid. If the session does not complete within this deadline,
	// it will be considered as failed.
	// +optional
	Deadline *metav1.Time `json:"deadline,omitempty"`

	// TotalComponents represents the number of total components for this RestoreSession
	// +optional
	TotalComponents int32 `json:"totalComponents,omitempty"`

	// Components represents the individual component restore status
	// +optional
	// +mapType=granular
	Components map[string]ComponentRestoreStatus `json:"components,omitempty"`

	// Hooks represents the hook execution status
	// +optional
	Hooks HookStatus `json:"hooks,omitempty"`

	// Dependencies specifies whether the objects required by this RestoreSession exist or not
	// +optional
	Dependencies []ResourceFoundStatus `json:"dependencies,omitempty"`

	// PausedBackups represents the list of backups that have been paused before restore.
	// +optional
	PausedBackups []kmapi.TypedObjectReference `json:"pausedBackups,omitempty"`

	// Conditions specifies a list of conditions related to this restore session
	// +optional
	Conditions []kmapi.Condition `json:"conditions,omitempty"`
}

type RetentionPolicyApplyPhase string

type RetentionPolicyApplyStatus struct {
	// Ref points to the RetentionPolicy CR that is being used to cleanup the old Snapshots for this session.
	Ref kmapi.ObjectReference `json:"ref,omitempty"`

	// Repository specifies the name of the Repository on which the RetentionPolicy has been applied.
	Repository string `json:"repository,omitempty"`
	// Phase specifies the state of retention policy apply process
	// +optional
	Phase RetentionPolicyApplyPhase `json:"phase,omitempty"`

	// Error represents the reason if the retention policy applying fail
	// +optional
	Error string `json:"error,omitempty"`
}

type RetentionPolicyStatus struct {
	// Ref indicates the RetentionPolicy object reference.
	Ref kmapi.ObjectReference `json:"ref,omitempty"`

	// Found indicates whether the RetentionPolicy is Found or not
	// +optional
	Found *bool `json:"found,omitempty"`

	// Reason specifies the error messages found while checking the RetentionPolicy
	// +optional
	Reason string `json:"reason,omitempty"`
}

type RetryConfig struct {
	// MaxRetry specifies the maximum number of times KubeStash should retry the backup/restore process.
	// By default, KubeStash will retry only 1 time.
	// +kubebuilder:default=1
	// +kubebuilder:validation:Minimum=1
	MaxRetry int32 `json:"maxRetry,omitempty"`

	// The amount of time to wait before next retry. If you don't specify this field, KubeStash will retry immediately.
	// Format: 30s, 2m, 1h etc.
	// +optional
	Delay metav1.Duration `json:"delay,omitempty"`
}

type SchedulerSpec struct {
	// The schedule in Cron format, see https://en.wikipedia.org/wiki/Cron.
	Schedule string `json:"schedule"`

	// Optional deadline in seconds for starting the job if it misses scheduled
	// time for any reason.  Missed jobs executions will be counted as failed ones.
	// +optional
	StartingDeadlineSeconds *int64 `json:"startingDeadlineSeconds,omitempty"`

	// Specifies how to treat concurrent executions of a Job.
	// Valid values are:
	// - "Allow" (default): allows CronJobs to run concurrently;
	// - "Forbid": forbids concurrent runs, skipping next run if previous run hasn't finished yet;
	// - "Replace": cancels currently running job and replaces it with a new one
	// +optional
	ConcurrencyPolicy batchv1.ConcurrencyPolicy `json:"concurrencyPolicy,omitempty"`

	// This flag tells the controller to suspend subsequent executions, it does
	// not apply to already started executions.  Defaults to false.
	// +optional
	Suspend *bool `json:"suspend,omitempty"`

	// Specifies the job that will be created when executing a CronJob.
	JobTemplate JobTemplate `json:"jobTemplate"`

	// The number of successful finished jobs to retain. Value must be non-negative integer.
	// Defaults to 3.
	// +optional
	SuccessfulJobsHistoryLimit *int32 `json:"successfulJobsHistoryLimit,omitempty"`

	// The number of failed finished jobs to retain. Value must be non-negative integer.
	// Defaults to 1.
	// +optional
	FailedJobsHistoryLimit *int32 `json:"failedJobsHistoryLimit,omitempty"`
}

type Session struct {
	*SessionConfig `json:",inline"`

	// Addon specifies addon configuration that will be used to backup the target.
	Addon *AddonInfo `json:"addon,omitempty"`

	// Repositories specifies a list of repository information where the backed up data will be stored.
	// KubeStash will create the respective Repository CRs using this information.
	Repositories []RepositoryInfo `json:"repositories,omitempty"`
}

type SessionConfig struct {
	// Name specifies the name of the session
	Name string `json:"name,omitempty"`

	// Scheduler specifies the configuration for backup triggering CronJob
	Scheduler *SchedulerSpec `json:"scheduler,omitempty"`

	// Hooks specifies the backup hooks that should be executed before and/or after the backup.
	// +optional
	Hooks *BackupHooks `json:"hooks,omitempty"`

	// RetryConfig specifies the behavior of retry in case of a backup failure.
	// +optional
	RetryConfig *RetryConfig `json:"retryConfig,omitempty"`

	// Timeout specifies the maximum duration of backup. BackupSession will be considered Failed
	// if backup does not complete within this time limit. By default, KubeStash don't set any timeout for backup.
	// +optional
	Timeout *metav1.Duration `json:"timeout,omitempty"`

	// SessionHistoryLimit specifies how many backup Jobs and associate resources KubeStash should keep for debugging purpose.
	// The default value is 1.
	// +kubebuilder:default=1
	// +optional
	SessionHistoryLimit int32 `json:"sessionHistoryLimit,omitempty"`
}

type SessionStatus struct {
	// Name indicates the name of the session
	Name string `json:"name,omitempty"`

	// NextSchedule specifies when the next backup will execute for this session
	// +optional
	NextSchedule string `json:"nextSchedule,omitempty"`

	// Conditions specifies a list of conditions related to this session
	// +optional
	Conditions []kmapi.Condition `json:"conditions,omitempty"`
}

type SnapshotStatus struct {
	// Name indicates to the name of the Snapshot
	Name string `json:"name,omitempty"`

	// Phase indicate the phase of the Snapshot
	// +optional
	Phase storage.SnapshotPhase `json:"phase,omitempty"`

	// AppRef points to the application that is being backed up in this Snapshot
	AppRef *kmapi.TypedObjectReference `json:"appRef,omitempty"`

	// Repository indicates the name of the Repository where the Snapshot is being stored.
	Repository string `json:"repository,omitempty"`
}

type StorageStatus struct {
	// Ref indicates to the BackupStorage object.
	Ref kmapi.ObjectReference `json:"ref,omitempty"`

	// Phase indicates the current phase of the respective BackupStorage.
	// +optional
	Phase v1alpha1.BackupStoragePhase `json:"phase,omitempty"`

	// Reason specifies the error messages found while checking the BackupStorage phase
	// +optional
	Reason string `json:"reason,omitempty"`
}

type Summary struct {
	// Name of the respective BackupSession/RestoreSession
	Name string `json:"name,omitempty"`
	// Namespace of the respective invoker
	Namespace string `json:"namespace,omitempty"`

	// Invoker specifies the information about the invoker which resulted this session
	Invoker *kmapi.TypedObjectReference `json:"invoker,omitempty"`
	// Target specifies the target information that has been backed up /restored in this session
	Target *kmapi.TypedObjectReference `json:"target,omitempty"`
	// Status specifies the backup/restore status for the respective target
	Status TargetStatus `json:"status,omitempty"`
}

type TargetBackupSpec struct {
	// Name points to the identifier of the target that is being backed up.
	// It should match the name used as the identifier of a target in the `spec.targets` section.
	Name string `json:"name,omitempty"`

	// Addon specifies addon configuration that will be used to backup this target.
	Addon *AddonInfo `json:"addon,omitempty"`

	// Repositories specifies a list of repository information where the backed up data will be stored.
	// KubeStash will create the respective Repository CRs using this information.
	Repositories []RepositoryInfo `json:"repositories,omitempty"`
}

type TargetReference struct {
	// Name specifies an identifier for this target. This name will be used in the session to refer this target.
	Name string `json:"name,omitempty"`

	// AppRef points to the target that is subject to backup. The target should be in same namespace as the BackupBatch.
	AppRef *kmapi.TypedObjectReference `json:"appRef,omitempty"`
}

type TargetStatus struct {
	// Phase represents the backup/restore phase of the target
	Phase string `json:"phase,omitempty"`
	// Duration represents the amount of time it took to complete the backup/restore for this target.
	Duration string `json:"duration,omitempty"`
	// Error specifies the respective error message in case of backup/restore failure
	Error string `json:"error,omitempty"`
}

type TargetVolumeInfo struct {
	// Volumes indicates the list of volumes of targeted application that should be mounted on the backup/restore job.
	Volumes []ofst.Volume `json:"volumes,omitempty"`

	// VolumeMounts specifies the mount for the volumes specified in `Volumes` section
	VolumeMounts []core.VolumeMount `json:"volumeMounts,omitempty"`

	// VolumeClaimTemplates specifies a template for the PersistentVolumeClaims that will be created for each Pod in a StatefulSet.
	VolumeClaimTemplates []ofst.PersistentVolumeClaim `json:"volumeClaimTemplates,omitempty"`
}

type TaskReference struct {
	// Name indicates to the name of the task
	Name string `json:"name,omitempty"`

	// Variables specifies a list of variables and their sources that will be used to resolve the task.
	// +optional
	Variables []core.EnvVar `json:"variables,omitempty"`

	// Params specifies parameters for the task. You must provide the parameter in the Addon desired structure.
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	Params *runtime.RawExtension `json:"params,omitempty"`

	// TargetVolumes specifies which volumes from the target should be mounted in the backup/restore job/container.
	// +optional
	TargetVolumes *TargetVolumeInfo `json:"targetVolumes,omitempty"`

	// AddonVolumes lets you overwrite the volume sources used in the VolumeTemplate section of Addon.
	// Make sure that name of your volume matches with the name of the volume you want to overwrite.
	// +optional
	AddonVolumes []AddonVolumeInfo `json:"addonVolumes,omitempty"`
}

type VerificationStatus struct {
	// Name indicates the name of the respective verification strategy
	Name string `json:"name,omitempty"`

	// Phase represents the state of the verification process
	// +optional
	Phase BackupVerificationPhase `json:"phase,omitempty"`
}

type VerificationStrategy struct {
	// Name indicate the name of this strategy
	Name string `json:"name,omitempty"`

	// Repository specifies the name of the repository which data will be verified
	Repository string `json:"repository,omitempty"`

	// Verifier refers to the BackupVerification CR that defines how to verify this particular data
	Verifier *kmapi.TypedObjectReference `json:"verifier,omitempty"`

	// Params specifies the parameters that will be used by the verifier
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	Params *runtime.RawExtension `json:"params,omitempty"`

	// VerifyEvery specifies the frequency of backup verification
	// +kubebuilder:validation:Minimum=1
	VerifyEvery int32 `json:"verifyEvery,omitempty"`

	// OnFailure specifies what to do if the verification fail.
	// +optional
	OnFailure FailurePolicy `json:"onFailure,omitempty"`

	// RetryConfig specifies the behavior of the retry mechanism in case of a verification failure
	// +optional
	RetryConfig *RetryConfig `json:"retryConfig,omitempty"`
}