v1alpha1

type ClusterFenceState string

type ClusterMaintenanceMode struct {
	// StorageProvisioner indicates the type of the provisioner
	StorageProvisioner string `json:"storageProvisioner"`

	// TargetID indicates the storage or replication instance identifier for the StorageProvisioner
	TargetID string `json:"targetID"`

	// State from MaintenanceMode resource created for the StorageProvisioner
	State MModeState `json:"state"`

	// Conditions from MaintenanceMode resource created for the StorageProvisioner
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type ControllerType string

type DRAction string

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

	Spec   DRClusterSpec   `json:"spec,omitempty"`
	Status DRClusterStatus `json:"status,omitempty"`
}

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

type DRClusterPhase string

type DRClusterSpec struct {
	// CIDRs is a list of CIDR strings. An admin can use this field to indicate
	// the CIDRs that are used or could potentially be used for the nodes in
	// this managed cluster.  These will be used for the cluster fencing
	// operation for sync/Metro DR.
	CIDRs []string `json:"cidrs,omitempty"`

	// ClusterFence is a string that determines the desired fencing state of the cluster.
	ClusterFence ClusterFenceState `json:"clusterFence,omitempty"`

	// Region of a managed cluster determines it DR group.
	// All managed clusters in a region are considered to be in a sync group.
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="region is immutable"
	Region Region `json:"region"`

	// S3 profile name (in Ramen config) to use as a source to restore PV
	// related cluster state during recovery or relocate actions of applications
	// to this managed cluster;  hence, this S3 profile should be available to
	// successfully move the workload to this managed cluster.  For applications
	// that are active on this managed cluster, their PV related cluster state
	// is stored to S3 profiles of all other drclusters in the same
	// DRPolicy to enable recovery or relocate actions to those managed clusters.
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="s3ProfileName is immutable"
	S3ProfileName string `json:"s3ProfileName"`
}

type DRClusterStatus struct {
	Phase            DRClusterPhase           `json:"phase,omitempty"`
	Conditions       []metav1.Condition       `json:"conditions,omitempty"`
	MaintenanceModes []ClusterMaintenanceMode `json:"maintenanceModes,omitempty"`
}

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

	Spec   DRPlacementControlSpec   `json:"spec,omitempty"`
	Status DRPlacementControlStatus `json:"status,omitempty"`
}

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

type DRPlacementControlSpec struct {
	// PlacementRef is the reference to the PlacementRule used by DRPC
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:XValidation:rule="self == oldSelf", message="placementRef is immutable"
	PlacementRef v1.ObjectReference `json:"placementRef"`

	// ProtectedNamespaces is a list of namespaces that are protected by the DRPC.
	// Omitting this field means resources are only protected in the namespace controlled by the PlacementRef.
	// If this field is set, the PlacementRef and the DRPC must be in the RamenOpsNamespace as set in the Ramen Config.
	// If this field is set, the protected namespace resources are treated as unmanaged.
	// You can use a recipe to filter and coordinate the order of the resources that are protected.
	// +kubebuilder:validation:Optional
	ProtectedNamespaces *[]string `json:"protectedNamespaces,omitempty"`

	// DRPolicyRef is the reference to the DRPolicy participating in the DR replication for this DRPC
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:XValidation:rule="self == oldSelf", message="drPolicyRef is immutable"
	DRPolicyRef v1.ObjectReference `json:"drPolicyRef"`

	// PreferredCluster is the cluster name that the user preferred to run the application on
	PreferredCluster string `json:"preferredCluster,omitempty"`

	// FailoverCluster is the cluster name that the user wants to failover the application to.
	// If not sepcified, then the DRPC will select the surviving cluster from the DRPolicy
	FailoverCluster string `json:"failoverCluster,omitempty"`

	// Label selector to identify all the PVCs that need DR protection.
	// This selector is assumed to be the same for all subscriptions that
	// need DR protection. It will be passed in to the VRG when it is created
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:XValidation:rule="self == oldSelf", message="pvcSelector is immutable"
	PVCSelector metav1.LabelSelector `json:"pvcSelector"`

	// Action is either Failover or Relocate operation
	Action DRAction `json:"action,omitempty"`

	// +optional
	KubeObjectProtection *KubeObjectProtectionSpec `json:"kubeObjectProtection,omitempty"`
}

type DRPlacementControlStatus struct {
	Phase              DRState            `json:"phase,omitempty"`
	ObservedGeneration int64              `json:"observedGeneration,omitempty"`
	ActionStartTime    *metav1.Time       `json:"actionStartTime,omitempty"`
	ActionDuration     *metav1.Duration   `json:"actionDuration,omitempty"`
	Progression        ProgressionStatus  `json:"progression,omitempty"`
	PreferredDecision  PlacementDecision  `json:"preferredDecision,omitempty"`
	Conditions         []metav1.Condition `json:"conditions,omitempty"`
	ResourceConditions VRGConditions      `json:"resourceConditions,omitempty"`

	// LastUpdateTime is when was the last time a condition or the overall status was updated
	LastUpdateTime *metav1.Time `json:"lastUpdateTime,omitempty"`

	// lastGroupSyncTime is the time of the most recent successful synchronization of all PVCs
	//+optional
	LastGroupSyncTime *metav1.Time `json:"lastGroupSyncTime,omitempty"`

	// lastGroupSyncDuration is the longest time taken to sync
	// from the most recent successful synchronization of all PVCs
	//+optional
	LastGroupSyncDuration *metav1.Duration `json:"lastGroupSyncDuration,omitempty"`

	// lastGroupSyncBytes is the total bytes transferred from the most recent
	// successful synchronization of all PVCs
	//+optional
	LastGroupSyncBytes *int64 `json:"lastGroupSyncBytes,omitempty"`
}

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

	Spec   DRPolicySpec   `json:"spec,omitempty"`
	Status DRPolicyStatus `json:"status,omitempty"`
}

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

type DRPolicySpec struct {
	// scheduling Interval for replicating Persistent Volume
	// data to a peer cluster. Interval is typically in the
	// form <num><m,h,d>. Here <num> is a number, 'm' means
	// minutes, 'h' means hours and 'd' stands for days.
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Pattern=`^(|\d+[mhd])$`
	// +kubebuilder:validation:XValidation:rule="self == oldSelf", message="schedulingInterval is immutable"
	SchedulingInterval string `json:"schedulingInterval"`

	// Label selector to identify all the VolumeReplicationClasses.
	// This selector is assumed to be the same for all subscriptions that
	// need DR protection. It will be passed in to the VRG when it is created
	//+optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:={}
	// +kubebuilder:validation:XValidation:rule="self == oldSelf", message="replicationClassSelector is immutable"
	ReplicationClassSelector metav1.LabelSelector `json:"replicationClassSelector"`

	// Label selector to identify all the VolumeSnapshotClasses.
	// This selector is assumed to be the same for all subscriptions that
	// need DR protection. It will be passed in to the VRG when it is created
	//+optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:={}
	// +kubebuilder:validation:XValidation:rule="self == oldSelf", message="volumeSnapshotClassSelector is immutable"
	VolumeSnapshotClassSelector metav1.LabelSelector `json:"volumeSnapshotClassSelector"`

	// List of DRCluster resources that are governed by this policy
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:XValidation:rule="size(self) == 2", message="drClusters requires a list of 2 clusters"
	// +kubebuilder:validation:XValidation:rule="self == oldSelf", message="drClusters is immutable"
	DRClusters []string `json:"drClusters"`
}

type DRPolicyStatus struct {
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type DRState string

type Identifier struct {
	// ID contains the globally unique storage identifier that identifies
	// the storage or replication backend
	ID string `json:"id"`

	// Modes is a list of maintenance modes that need to be activated on the storage
	// backend, prior to various Ramen related orchestration. This is read from the label
	// "ramendr.openshift.io/maintenancemodes" on the StorageClass or VolumeReplicationClass,
	// the value for which is a comma separated list of maintenance modes.
	//+optional
	Modes []MMode `json:"modes,omitempty"`
}

type KubeObjectProtectionSpec struct {
	// Preferred time between captures
	//+optional
	//+kubebuilder:validation:Format=duration
	CaptureInterval *metav1.Duration `json:"captureInterval,omitempty"`

	// Name of the Recipe to reference for capture and recovery workflows and volume selection.
	//+optional
	RecipeRef *RecipeRef `json:"recipeRef,omitempty"`

	// Recipe parameter definitions
	//+optional
	RecipeParameters map[string][]string `json:"recipeParameters,omitempty"`

	// Label selector to identify all the kube objects that need DR protection.
	// +optional
	KubeObjectSelector *metav1.LabelSelector `json:"kubeObjectSelector,omitempty"`
}

type KubeObjectProtectionStatus struct {
	//+optional
	CaptureToRecoverFrom *KubeObjectsCaptureIdentifier `json:"captureToRecoverFrom,omitempty"`
}

type KubeObjectsCaptureIdentifier struct {
	Number int64 `json:"number"`
	//+nullable
	StartTime       metav1.Time `json:"startTime,omitempty"`
	StartGeneration int64       `json:"startGeneration,omitempty"`
}

type MMode string

type MModeState string

type MModeStatusConditionType string

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

	Spec   MaintenanceModeSpec   `json:"spec,omitempty"`
	Status MaintenanceModeStatus `json:"status,omitempty"`
}

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

type MaintenanceModeSpec struct {
	// StorageProvisioner indicates the type of the provisioner, and is matched with provisioner string present in the
	// StorageClass and/or VolumeReplicationClass for PVCs that are DR protected
	StorageProvisioner string `json:"storageProvisioner"`

	// TargetID indicates the storage or replication instance identifier for the StorageProvisioner that needs to handle
	// the requested maintenance modes. It is read using ramen specific labels on the StorageClass or
	// the VolumeReplicationClass as set by the storage provisioner
	TargetID string `json:"targetID,omitempty"`

	// Modes are the desired maintenance modes that the storage provisioner needs to act on
	Modes []MMode `json:"modes,omitempty"`
}

type MaintenanceModeStatus struct {
	State              MModeState         `json:"state,omitempty"`
	ObservedGeneration int64              `json:"observedGeneration,omitempty"`
	Conditions         []metav1.Condition `json:"conditions,omitempty"`
}

type PlacementDecision struct {
	ClusterName      string `json:"clusterName,omitempty"`
	ClusterNamespace string `json:"clusterNamespace,omitempty"`
}

type ProgressionStatus string

type ProtectedPVC struct {
	// Name of the namespace the PVC is in
	//+optional
	Namespace string `json:"namespace,omitempty"`

	// Name of the VolRep/PVC resource
	//+optional
	Name string `json:"name,omitempty"`

	// VolSyncPVC can be used to denote whether this PVC is protected by VolSync. Defaults to "false".
	//+optional
	ProtectedByVolSync bool `json:"protectedByVolSync,omitempty"`

	//+optional
	StorageIdentifiers `json:",inline,omitempty"`

	// Name of the StorageClass required by the claim.
	//+optional
	StorageClassName *string `json:"storageClassName,omitempty"`

	// Annotations for the PVC
	//+optional
	Annotations map[string]string `json:"annotations,omitempty"`

	// Labels for the PVC
	//+optional
	Labels map[string]string `json:"labels,omitempty"`

	// AccessModes set in the claim to be replicated
	//+optional
	AccessModes []corev1.PersistentVolumeAccessMode `json:"accessModes,omitempty"`

	// Resources set in the claim to be replicated
	//+optional
	Resources corev1.VolumeResourceRequirements `json:"resources,omitempty"`

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

	// Time of the most recent successful synchronization for the PVC, if
	// protected in the async or volsync mode
	//+optional
	LastSyncTime *metav1.Time `json:"lastSyncTime,omitempty"`

	// Duration of recent synchronization for PVC, if
	// protected in the async or volsync mode
	//+optional
	LastSyncDuration *metav1.Duration `json:"lastSyncDuration,omitempty"`

	// Bytes transferred per sync, if protected in async mode only
	LastSyncBytes *int64 `json:"lastSyncBytes,omitempty"`
}

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

	Spec ProtectedVolumeReplicationGroupListSpec `json:"spec,omitempty"`
	// +optional
	Status *ProtectedVolumeReplicationGroupListStatus `json:"status,omitempty"`
}

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

type ProtectedVolumeReplicationGroupListSpec struct {
	// ProfileName is the name of the S3 profile in the Ramen operator config map
	// specifying the store to be queried
	S3ProfileName string `json:"s3ProfileName"`
}

type ProtectedVolumeReplicationGroupListStatus struct {
	// SampleTime is a timestamp representing the node time when the specified
	// store was last queried. It is represented in RFC3339 form and is in UTC.
	SampleTime metav1.Time `json:"sampleTime,omitempty"`

	// Items is a list of VolumeReplicationGroup objects represented in
	// the specified store when it was last queried.
	Items []VolumeReplicationGroup `json:"items,omitempty"`
}

type RamenConfig struct {
	metav1.TypeMeta `json:",inline"`

	// ControllerManagerConfigurationSpec returns the configurations for controllers
	cfg.ControllerManagerConfigurationSpec `json:",inline"`

	// RamenControllerType defines the type of controller to run
	RamenControllerType ControllerType `json:"ramenControllerType"`

	// Map of S3 store profiles
	S3StoreProfiles []S3StoreProfile `json:"s3StoreProfiles,omitempty"`

	// MaxConcurrentReconciles is the maximum number of concurrent Reconciles which can be run.
	// Defaults to 1.
	MaxConcurrentReconciles int `json:"maxConcurrentReconciles,omitempty"`

	// dr-cluster operator deployment/undeployment automation configuration
	DrClusterOperator struct {
		// dr-cluster operator deployment/undeployment automation enabled
		DeploymentAutomationEnabled bool `json:"deploymentAutomationEnabled,omitempty"`

		// Enable s3 secret distribution and management across dr-clusters
		S3SecretDistributionEnabled bool `json:"s3SecretDistributionEnabled,omitempty"`

		// channel name
		ChannelName string `json:"channelName,omitempty"`

		// package name
		PackageName string `json:"packageName,omitempty"`

		// namespace name
		NamespaceName string `json:"namespaceName,omitempty"`

		// catalog source name
		CatalogSourceName string `json:"catalogSourceName,omitempty"`

		// catalog source namespace name
		CatalogSourceNamespaceName string `json:"catalogSourceNamespaceName,omitempty"`

		// cluster service version name
		ClusterServiceVersionName string `json:"clusterServiceVersionName,omitempty"`
	} `json:"drClusterOperator,omitempty"`

	// VolSync configuration
	VolSync struct {
		// Disabled is used to disable VolSync usage in Ramen. Defaults to false.
		Disabled bool `json:"disabled,omitempty"`

		// Default cephFS CSIDriver name used to enable ROX volumes. If this name matches
		// the PVC's storageclass provisioner, a new storageclass will be created and the
		// name of it passed to VolSync alongside the readOnly flag access mode.
		CephFSCSIDriverName string `json:"cephFSCSIDriverName,omitempty"`

		// destinationCopyMethod indicates the method that should be used when syncing
		// from source to destination. Should be Snapshot/Direct
		// default: Snapshot
		DestinationCopyMethod string `json:"destinationCopyMethod,omitempty"`
	} `json:"volSync,omitempty"`

	KubeObjectProtection struct {
		// Disabled is used to disable KubeObjectProtection usage in Ramen.
		Disabled bool `json:"disabled,omitempty"`
		// Velero namespace input
		VeleroNamespaceName string `json:"veleroNamespaceName,omitempty"`
	} `json:"kubeObjectProtection,omitempty"`

	MultiNamespace struct {
		// Enables feature to protect resources in namespaces other than VRG's
		FeatureEnabled bool `json:"FeatureEnabled,omitempty"`
	} `json:"multiNamespace,omitempty"`

	// Unprotect deleted or deselected PVCs
	VolumeUnprotectionEnabled bool `json:"volumeUnprotectionEnabled,omitempty"`

	// RamenOpsNamespace is the namespace where resources for unmanaged apps are created
	RamenOpsNamespace string `json:"ramenOpsNamespace,omitempty"`
}

type RecipeRef struct {
	// Name of namespace recipe is in
	//+optional
	Namespace string `json:"namespace,omitempty"`

	// Name of recipe
	//+optional
	Name string `json:"name,omitempty"`
}

type Region string

type ReplicationState string

type S3StoreProfile struct {
	// Name of this S3 profile
	S3ProfileName string `json:"s3ProfileName"`

	// Name of the S3 bucket to protect and recover PV related cluster-data of
	// subscriptions protected by this DR policy.  This S3 bucket name is used
	// across all DR policies that use this S3 profile. Objects deposited in
	// this bucket are prefixed with the namespace-qualified name of the VRG to
	// uniquely identify objects of a particular subscription (an instance of an
	// application).  A single S3 bucket at a given endpoint may be shared by
	// multiple DR placements that are concurrently active in a given hub.
	// However, sharing an S3 bucket across multiple hub clusters can cause
	// object key name conflicts of cluster data uploaded to the bucket,
	// resulting in undefined and undesired side-effects. Hence, do not share an
	// S3 bucket at a given S3 endpoint across multiple hub clusters.  Bucket
	// name should follow AWS bucket naming rules:
	// https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html
	S3Bucket string `json:"s3Bucket"`

	// S3 compatible endpoint of the object store of this S3 profile
	S3CompatibleEndpoint string `json:"s3CompatibleEndpoint"`

	// S3 Region; the AWS go client SDK does not have a default region; hence,
	// this is a mandatory field.
	// https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html
	S3Region string `json:"s3Region"`

	// Reference to the secret that contains the S3 access key id and s3 secret
	// access key with the keys AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY
	// respectively.
	S3SecretRef v1.SecretReference `json:"s3SecretRef"`
	//+optional
	VeleroNamespaceSecretKeyRef *v1.SecretKeySelector `json:"veleroNamespaceSecretKeyRef,omitempty"`
	// A CA bundle to use when verifying TLS connections to the provider
	//+optional
	CACertificates []byte `json:"caCertificates,omitempty"`
}

type State string

type StorageIdentifiers struct {
	// StorageProvisioners contains the provisioner name of the CSI driver used to provision this
	// PVC (extracted from the storageClass that was used for provisioning)
	//+optional
	StorageProvisioner string `json:"csiProvisioner,omitempty"`

	// StorageID contains the globally unique storage identifier, as reported by the storage backend
	// on the StorageClass as the value for the label "ramendr.openshift.io/storageid", that identifies
	// the storage backend that was used to provision the volume. It is used to label different StorageClasses
	// across different kubernetes clusters, that potentially share the same storage backend.
	// It also contains any maintenance modes that the storage backend requires during vaious Ramen actions
	//+optional
	StorageID Identifier `json:"storageID,omitempty"`

	// ReplicationID contains the globally unique replication identifier, as reported by the storage backend
	// on the VolumeReplicationClass as the value for the label "ramendr.openshift.io/replicationid", that
	// identifies the storage backends across 2 (or more) storage instances where the volume is replicated
	// It also contains any maintenance modes that the replication backend requires during vaious Ramen actions
	//+optional
	ReplicationID Identifier `json:"replicationID,omitempty"`
}

type VRGAction string

type VRGAsyncSpec struct {
	// Label selector to identify the VolumeReplicationClass resources
	// that are scanned to select an appropriate VolumeReplicationClass
	// for the VolumeReplication resource.
	//+optional
	ReplicationClassSelector metav1.LabelSelector `json:"replicationClassSelector,omitempty"`

	// Label selector to identify the VolumeSnapshotClass resources
	// that are scanned to select an appropriate VolumeSnapshotClass
	// for the VolumeReplication resource when using VolSync.
	//+optional
	VolumeSnapshotClassSelector metav1.LabelSelector `json:"volumeSnapshotClassSelector,omitempty"`

	// scheduling Interval for replicating Persistent Volume
	// data to a peer cluster. Interval is typically in the
	// form <num><m,h,d>. Here <num> is a number, 'm' means
	// minutes, 'h' means hours and 'd' stands for days.
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Pattern=`^\d+[mhd]$`
	SchedulingInterval string `json:"schedulingInterval"`
}

type VRGConditions struct {
	// ResourceMeta represents the VRG resoure.
	// +required
	ResourceMeta VRGResourceMeta `json:"resourceMeta,omitempty"`

	// Conditions represents the conditions of this resource on a managed cluster.
	// +required
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type VRGResourceMeta struct {
	// Kind is the kind of the Kubernetes resource.
	// +optional
	Kind string `json:"kind"`

	// Name is the name of the Kubernetes resource.
	Name string `json:"name"`

	// Namespace is the namespace of the Kubernetes resource.
	Namespace string `json:"namespace"`

	// A sequence number representing a specific generation of the desired state.
	Generation int64 `json:"generation"`

	// List of PVCs that are protected by the VRG resource
	ProtectedPVCs []string `json:"protectedpvcs,omitempty"`
}

type VRGSyncSpec struct{}

type VolSyncReplicationDestinationSpec struct {
	// protectedPVC contains the information about the PVC to be protected by VolSync
	//+optional
	ProtectedPVC ProtectedPVC `json:"protectedPVC,omitempty"`
}

type VolSyncReplicationSourceSpec struct {
	// protectedPVC contains the information about the PVC to be protected by VolSync
	//+optional
	ProtectedPVC ProtectedPVC `json:"protectedPVC,omitempty"`
}

type VolSyncSpec struct {
	// rdSpec array contains the PVCs information that will/are be/being protected by VolSync
	//+optional
	RDSpec []VolSyncReplicationDestinationSpec `json:"rdSpec,omitempty"`

	// disabled when set, all the VolSync code is bypassed. Default is 'false'
	Disabled bool `json:"disabled,omitempty"`
}

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

	Spec   VolumeReplicationGroupSpec   `json:"spec,omitempty"`
	Status VolumeReplicationGroupStatus `json:"status,omitempty"`
}

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

type VolumeReplicationGroupSpec struct {
	// Label selector to identify all the PVCs that are in this group
	// that needs to be replicated to the peer cluster.
	PVCSelector metav1.LabelSelector `json:"pvcSelector"`

	// Desired state of all volumes [primary or secondary] in this replication group;
	// this value is propagated to children VolumeReplication CRs
	ReplicationState ReplicationState `json:"replicationState"`

	// List of unique S3 profiles in RamenConfig that should be used to store
	// and forward PV related cluster state to peer DR clusters.
	S3Profiles []string `json:"s3Profiles"`

	//+optional
	Async *VRGAsyncSpec `json:"async,omitempty"`
	//+optional
	Sync *VRGSyncSpec `json:"sync,omitempty"`

	// volsync defines the configuration when using VolSync plugin for replication.
	//+optional
	VolSync VolSyncSpec `json:"volSync,omitempty"`

	// PrepareForFinalSync when set, it tells VRG to prepare for the final sync from source to destination
	// cluster. Final sync is needed for relocation only, and for VolSync only
	//+optional
	PrepareForFinalSync bool `json:"prepareForFinalSync,omitempty"`

	// runFinalSync used to indicate whether final sync is needed. Final sync is needed for
	// relocation only, and for VolSync only
	//+optional
	RunFinalSync bool `json:"runFinalSync,omitempty"`

	// Action is either Failover or Relocate
	//+optional
	Action VRGAction `json:"action,omitempty"`
	//+optional
	KubeObjectProtection *KubeObjectProtectionSpec `json:"kubeObjectProtection,omitempty"`

	// ProtectedNamespaces is a list of namespaces that are considered for protection by the VRG.
	// Omitting this field means resources are only protected in the namespace where VRG is.
	// If this field is set, the VRG must be in the Ramen Ops Namespace as configured in the Ramen Config.
	// If this field is set, the protected namespace resources are treated as unmanaged.
	// You can use a recipe to filter and coordinate the order of the resources that are protected.
	//+optional
	ProtectedNamespaces *[]string `json:"protectedNamespaces,omitempty"`
}

type VolumeReplicationGroupStatus struct {
	State State `json:"state,omitempty"`

	// All the protected pvcs
	ProtectedPVCs []ProtectedPVC `json:"protectedPVCs,omitempty"`

	// Conditions are the list of VRG's summary conditions and their status.
	Conditions []metav1.Condition `json:"conditions,omitempty"`

	// observedGeneration is the last generation change the operator has dealt with
	//+optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
	//+nullable
	LastUpdateTime metav1.Time `json:"lastUpdateTime,omitempty"`
	//+optional
	KubeObjectProtection KubeObjectProtectionStatus `json:"kubeObjectProtection,omitempty"`

	PrepareForFinalSyncComplete bool `json:"prepareForFinalSyncComplete,omitempty"`
	FinalSyncComplete           bool `json:"finalSyncComplete,omitempty"`

	// lastGroupSyncTime is the time of the most recent successful synchronization of all PVCs
	//+optional
	LastGroupSyncTime *metav1.Time `json:"lastGroupSyncTime,omitempty"`

	// lastGroupSyncDuration is the max time from all the successful synced PVCs
	//+optional
	LastGroupSyncDuration *metav1.Duration `json:"lastGroupSyncDuration,omitempty"`

	// lastGroupSyncBytes is the total bytes transferred from the most recent
	// successful synchronization of all PVCs
	//+optional
	LastGroupSyncBytes *int64 `json:"lastGroupSyncBytes,omitempty"`
}