v1alpha2

type AttachedVirtualMachine struct {
	// Name of attached VirtualMachine.
	Name string `json:"name,omitempty"`
	// Flag indicating that VirtualDisk is currently being used by this attached VirtualMachine.
	Mounted bool `json:"mounted,omitempty"`
}

type BlockDeviceAttachmentPhase string

type BlockDeviceKind string

type BlockDeviceSpecRef struct {
	Kind BlockDeviceKind `json:"kind"`
	// The name of attached resource.
	Name string `json:"name"`
}

type BlockDeviceStatusRef struct {
	Kind BlockDeviceKind `json:"kind"`
	// The name of attached resource.
	Name string `json:"name"`
	// The size of attached block device.
	Size string `json:"size"`
	// The block device is attached to the virtual machine.
	Attached bool `json:"attached"`
	// The name of attached block device.
	// +kubebuilder:example=sda
	Target string `json:"target,omitempty"`
	// Block device is attached via hot plug connection.
	Hotplugged bool `json:"hotplugged,omitempty"`
	// The name of the `VirtualMachineBlockDeviceAttachment` resource that defines hot plug disk connection to the virtual machine.
	VirtualMachineBlockDeviceAttachmentName string `json:"virtualMachineBlockDeviceAttachmentName,omitempty"`
}

type BootloaderType string

type CPU struct {
	// +kubebuilder:validation:Required
	Type CPUType `json:"type"`
	// CPU model name. For more information about CPU models and topology, refer to the [libvirt docs](https://libvirt.org/formatdomain.html#cpu-model-and-topology).
	//
	// +kubebuilder:validation:MinLength=1
	// +kubebuilder:example=IvyBridge
	Model string `json:"model,omitempty"`
	// List of CPU instructions (features) required when type=Features.
	// For more information about CPU features, refer to the [libvirt docs](https://libvirt.org/formatdomain.html#cpu-model-and-topology).
	//
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:example={mmx, vmx, sse2}
	Features []string `json:"features,omitempty"`
	// Create a CPU model based on intersecting CPU features for selected nodes.
	Discovery CpuDiscovery `json:"discovery,omitempty"`
}

type CPUSpec struct {
	// Specifies the number of cores inside the VM. The value must be greater or equal 1.
	// +kubebuilder:validation:Format:=int32
	// +kubebuilder:validation:Minimum=1
	Cores int `json:"cores"`

	// Guaranteed share of CPU that will be allocated to the VM. Specified as a percentage.
	// +kubebuilder:default:="100%"
	// +kubebuilder:validation:Enum:={"5%", "10%", "25%", "50%", "100%"}
	CoreFraction string `json:"coreFraction,omitempty"`
}

type CPUStatus struct {
	// Current number of cores inside the VM.
	Cores int `json:"cores"`
	// Current CoreFraction.
	CoreFraction string `json:"coreFraction,omitempty"`
	// Requested cores.
	RequestedCores resource.Quantity `json:"requestedCores,omitempty"`
	// runtime overhead.
	RuntimeOverhead resource.Quantity `json:"runtimeOverhead,omitempty"`
	// Topology with Cores count and Sockets count.
	Topology Topology `json:"topology,omitempty"`
}

type CPUType string

type Checksum struct {
	// +kubebuilder:example:="f3b59bed9f91e32fac1210184fcff6f5"
	// +kubebuilder:validation:Pattern="^[0-9a-fA-F]{32}$"
	// +kubebuilder:validation:MinLength:=32
	// +kubebuilder:validation:MaxLength:=32
	MD5 string `json:"md5,omitempty"`
	// +kubebuilder:example:="78be890d71dde316c412da2ce8332ba47b9ce7a29d573801d2777e01aa20b9b5"
	// +kubebuilder:validation:Pattern="^[0-9a-fA-F]{64}$"
	// +kubebuilder:validation:MinLength:=64
	// +kubebuilder:validation:MaxLength:=64
	SHA256 string `json:"sha256,omitempty"`
}

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

	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec ClusterVirtualImageSpec `json:"spec"`

	Status ClusterVirtualImageStatus `json:"status,omitempty"`
}

type ClusterVirtualImageContainerImage struct {
	// Path to the image in the container registry.
	// +kubebuilder:example:="registry.example.com/images/slackware:15"
	// +kubebuilder:validation:Pattern:=`^(?P<name>(?:(?P<domain>(?:(?:localhost|[\w-]+(?:\.[\w-]+)+)(?::\d+)?)|[\w]+:\d+)/)?(?P<image>[a-z0-9_.-]+(?:/[a-z0-9_.-]+)*))(?::(?P<tag>[\w][\w.-]{0,127}))?(?:@(?P<digest>[A-Za-z][A-Za-z0-9]*(?:[+.-_][A-Za-z][A-Za-z0-9]*)*:[0-9a-fA-F]{32,}))?$`
	Image           string          `json:"image"`
	ImagePullSecret ImagePullSecret `json:"imagePullSecret,omitempty"`
	// CA chain in Base64 format to verify the container registry.
	// +kubebuilder:example:="YWFhCg=="
	CABundle []byte `json:"caBundle,omitempty"`
}

type ClusterVirtualImageDataSource struct {
	Type           DataSourceType                     `json:"type"`
	HTTP           *DataSourceHTTP                    `json:"http,omitempty"`
	ContainerImage *ClusterVirtualImageContainerImage `json:"containerImage,omitempty"`
	ObjectRef      *ClusterVirtualImageObjectRef      `json:"objectRef,omitempty"`
}

type ClusterVirtualImageList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`

	// Items provides a list of CVIs.
	Items []ClusterVirtualImage `json:"items"`
}

type ClusterVirtualImageObjectRef struct {
	Kind ClusterVirtualImageObjectRefKind `json:"kind"`
	// Name of the existing VirtualImage, ClusterVirtualImage, VirtualDisk or VirtualDiskSnapshot resource.
	Name string `json:"name"`
	// Namespace where the VirtualImage, VirtualDisk or VirtualDiskSnapshot resource is located.
	Namespace string `json:"namespace,omitempty"`
}

type ClusterVirtualImageObjectRefKind string

type ClusterVirtualImageSpec struct {
	DataSource ClusterVirtualImageDataSource `json:"dataSource"`
}

type ClusterVirtualImageStatus struct {
	// Image download speed from an external source. Appears only during the `Provisioning` phase.
	DownloadSpeed *StatusSpeed `json:"downloadSpeed,omitempty"`
	// Discovered image size data.
	Size ImageStatusSize `json:"size,omitempty"`
	// Discovered image format.
	Format string `json:"format,omitempty"`
	// Defines whether the image is in a format that needs to be mounted as a CD-ROM drive, such as iso and so on.
	CDROM bool `json:"cdrom,omitempty"`
	// Current status of the ClusterVirtualImage resource:
	// * `Pending`: The resource has been created and is on a waiting queue.
	// * `Provisioning`: The resource is being created: copying, downloading, or building of the image is in progress.
	// * `WaitForUserUpload`: Waiting for the user to upload the image. The endpoint to upload the image is specified in `.status.uploadCommand`.
	// * `Ready`: The resource has been created and is ready to use.
	// * `Failed`: There was an error when creating the resource.
	// * `Terminating`: The resource is being deleted.
	// +kubebuilder:validation:Enum:={Pending,Provisioning,WaitForUserUpload,Ready,Failed,Terminating}
	Phase ImagePhase `json:"phase,omitempty"`
	// Progress of copying an image from the source to DVCR. Appears only during the `Provisioning' phase.
	Progress string `json:"progress,omitempty"`
	// UID of the source (VirtualImage, ClusterVirtualImage, VirtualDisk or VirtualDiskSnapshot) used when creating the cluster virtual image.
	SourceUID *types.UID `json:"sourceUID,omitempty"`
	// The latest available observations of an object's current state.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
	// Resource generation last processed by the controller.
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
	// Deprecated. Use `imageUploadURLs` instead.
	UploadCommand   string                          `json:"uploadCommand,omitempty"`
	ImageUploadURLs *ImageUploadURLs                `json:"imageUploadURLs,omitempty"`
	Target          ClusterVirtualImageStatusTarget `json:"target,omitempty"`
	// Displays the list of namespaces where the image is currently used.
	UsedInNamespaces []string `json:"usedInNamespaces,omitempty"`
}

type ClusterVirtualImageStatusTarget struct {
	// Created image in DVCR.
	// +kubebuilder:example:="dvcr.<dvcr-namespace>.svc/cvi/<image-name>:latest"
	RegistryURL string `json:"registryURL,omitempty"`
}

type CoreFractionValue int

type CpuDiscovery struct {
	// A selection of nodes to be used as the basis for creating a universal CPU model.
	NodeSelector metav1.LabelSelector `json:"nodeSelector,omitempty"`
}

type CpuFeatures struct {
	//  List of CPU features for this model.
	//
	// +kubebuilder:example={mmx, vmx, sse2}
	Enabled []string `json:"enabled,omitempty"`
	// List of unused processor features additionally available for a given group of nodes.
	//
	// +kubebuilder:example={ssse3, vme}
	NotEnabledCommon []string `json:"notEnabledCommon,omitempty"`
}

type DataSourceHTTP struct {
	// Checksum to verify integrity and consistency of the downloaded file. The file must match all specified checksums.
	Checksum *Checksum `json:"checksum,omitempty"`
	// URL of the file for creating an image. The following file formats are supported:
	// * qcow2
	// * vmdk
	// * vdi
	// * iso
	// * raw
	// The file can be compressed into an archive in one of the following formats:
	// * gz
	// * xz
	// +kubebuilder:example:="https://mirror.example.com/images/slackware-15.qcow.gz"
	// +kubebuilder:validation:Pattern=`^http[s]?:\/\/(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+$`
	URL string `json:"url"`
	// CA chain in Base64 format to verify the URL.
	// +kubebuilder:example:="YWFhCg=="
	CABundle []byte `json:"caBundle,omitempty"`
}

type DataSourceType string

type DiskPhase string

type DiskTarget struct {
	// Created PersistentVolumeClaim name for the Kubernetes storage.
	PersistentVolumeClaim string `json:"persistentVolumeClaimName,omitempty"`
}

type Disruptions struct {
	RestartApprovalMode RestartApprovalMode `json:"restartApprovalMode,omitempty"`
}

type ImagePhase string

type ImagePullSecret struct {
	// Name of the secret keeping container registry credentials.
	Name string `json:"name,omitempty"`
	// Namespace where `imagePullSecret` is located.
	Namespace string `json:"namespace,omitempty"`
}

type ImagePullSecretName struct {
	// Name of the secret keeping container registry credentials, which must be located in the same namespace.
	Name string `json:"name,omitempty"`
}

type ImageStatusSize struct {
	// Image size in human-readable format.
	// +kubebuilder:example:="199M"
	Stored string `json:"stored,omitempty"`
	// Image size in bytes.
	// +kubebuilder:example:=199001234
	StoredBytes string `json:"storedBytes,omitempty"`
	// Unpacked image size in human-readable format.
	// +kubebuilder:example:="1G"
	Unpacked string `json:"unpacked,omitempty"`
	// Unpacked image size in bytes.
	// +kubebuilder:example:=1000000234
	UnpackedBytes string `json:"unpackedBytes,omitempty"`
}

type ImageUploadURLs struct {
	// Command to upload the image using `Ingress` from outside the cluster.
	External string `json:"external,omitempty"`
	// Command to upload the image using `Service` within the cluster.
	InCluster string `json:"inCluster,omitempty"`
}

type KeepIPAddress string

type LiveMigrationPolicy string

type MachinePhase string

type MemoryMinMax struct {
	// Minimum amount of memory.
	//
	// +kubebuilder:example="1Gi"
	Min resource.Quantity `json:"min,omitempty"`
	// Maximum amount of memory.
	//
	// +kubebuilder:example="8Gi"
	Max resource.Quantity `json:"max,omitempty"`
}

type MemorySpec struct {
	Size resource.Quantity `json:"size"`
}

type MemoryStatus struct {
	// Current memory size.
	Size resource.Quantity `json:"size"`
	// Memory runtime overhead.
	RuntimeOverhead resource.Quantity `json:"runtimeOverhead,omitempty"`
}

type MigrationResult string

type NameReplacement struct {
	// Selector to choose resources for name replacement.
	From NameReplacementFrom `json:"from"`
	// New resource name.
	To string `json:"to"`
}

type NameReplacementFrom struct {
	// Kind of a resource to rename.
	Kind string `json:"kind,omitempty"`
	// Current name of a resource to rename.
	Name string `json:"name"`
}

type NetworksSpec struct {
	Type                         string `json:"type"`
	Name                         string `json:"name,omitempty"`
	VirtualMachineMACAddressName string `json:"virtualMachineMACAddressName,omitempty"`
}

type NetworksStatus struct {
	Type                         string `json:"type"`
	Name                         string `json:"name,omitempty"`
	MAC                          string `json:"macAddress,omitempty"`
	VirtualMachineMACAddressName string `json:"virtualMachineMACAddressName,omitempty"`
}

type NodeSelector struct {
	// A map of {key,value} pairs.
	// A single {key,value} pair in the matchLabels map is equivalent to an element of matchExpressions whose key field is "key", operator is "In", and the value array contains only "value".
	// The requirements are ANDed.
	MatchLabels map[string]string `json:"matchLabels,omitempty"`
	// A list of node selector requirements by node's labels.
	MatchExpressions []corev1.NodeSelectorRequirement `json:"matchExpressions,omitempty"`
}

type OsType string

type Provisioning struct {
	Type ProvisioningType `json:"type"`
	// Inline cloud-init userdata script.
	UserData    string       `json:"userData,omitempty"`
	UserDataRef *UserDataRef `json:"userDataRef,omitempty"`
	SysprepRef  *SysprepRef  `json:"sysprepRef,omitempty"`
}

type ProvisioningType string

type ResourceRef struct {
	// Kind of the resource.
	Kind string `json:"kind,omitempty"`
	// API version of the resource.
	ApiVersion string `json:"apiVersion,omitempty"`
	// Name of the resource.
	Name string `json:"name,omitempty"`
}

type ResourcesStatus struct {
	CPU    CPUStatus    `json:"cpu,omitempty"`
	Memory MemoryStatus `json:"memory,omitempty"`
}

type RestartApprovalMode string

type RestoreMode string

type RunPolicy string

type SizingPolicy struct {
	// Memory sizing policy.
	Memory *SizingPolicyMemory `json:"memory,omitempty"`
	// Allowed values of the `coreFraction` parameter.
	CoreFractions []CoreFractionValue `json:"coreFractions,omitempty"`
	// Allowed values of the `dedicatedCores` parameter.
	DedicatedCores []bool `json:"dedicatedCores,omitempty"`
	// The policy applies for a specified range of the number of CPU cores.
	Cores *SizingPolicyCores `json:"cores,omitempty"`
}

type SizingPolicyCores struct {
	// Minimum number of CPU cores.
	//
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:example=1
	Min int `json:"min"`
	// Maximum number of CPU cores.
	//
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Maximum=1024
	// +kubebuilder:example=10
	Max int `json:"max"`
	// Discretization step for the CPU core number. For example, the combination of `min=2`, `max=10`, and `step=4` allows to set the number of virtual machine CPU cores to 2, 6, or 10.
	//
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:example=1
	Step int `json:"step,omitempty"`
}

type SizingPolicyMemory struct {
	MemoryMinMax `json:",inline"`
	// Memory size discretization step. For example, the combination of `min=2Gi, `max=4Gi` and `step=1Gi` allows to set the virtual machine memory size to 2Gi, 3Gi, or 4Gi.
	//
	// +kubebuilder:example="512Mi"
	Step resource.Quantity `json:"step,omitempty"`

	// Amount of memory per CPU core.
	PerCore SizingPolicyMemoryPerCore `json:"perCore,omitempty"`
}

type SizingPolicyMemoryPerCore struct {
	MemoryMinMax `json:",inline"`
}

type StatusSpeed struct {
	// Average download speed.
	// +kubebuilder:example:="1 Mbps"
	Avg string `json:"avg,omitempty"`
	// Average download speed in bytes per second.
	// +kubebuilder:example:=1012345
	AvgBytes string `json:"avgBytes,omitempty"`
	// Current download speed.
	// +kubebuilder:example:="5 Mbps"
	Current string `json:"current,omitempty"`
	// Current download speed in bytes per second.
	// +kubebuilder:example:=5123456
	CurrentBytes string `json:"currentBytes,omitempty"`
}

type StorageType string

type SysprepRef struct {
	// The kind of existing Windows sysprep automation resource.
	// The following options are supported:
	//  - Secret
	// +kubebuilder:validation:Enum:={Secret}
	// +kubebuilder:default:="Secret"
	Kind SysprepRefKind `json:"kind,omitempty"`
	Name string         `json:"name"`
}

type SysprepRefKind string

type Topology struct {
	// Current number of cores inside the VM.
	CoresPerSocket int `json:"coresPerSocket"`
	// Current number of cores inside the VM.
	Sockets int `json:"sockets"`
}

type UserDataRef struct {
	// The kind of existing cloud-init automation resource.
	// The following options are supported:
	//   - Secret
	//
	// +kubebuilder:validation:Enum:={Secret}
	// +kubebuilder:default:="Secret"
	Kind UserDataRefKind `json:"kind,omitempty"`
	Name string          `json:"name"`
}

type UserDataRefKind string

type VMAffinity struct {
	NodeAffinity                     *corev1.NodeAffinity              `json:"nodeAffinity,omitempty"`
	VirtualMachineAndPodAffinity     *VirtualMachineAndPodAffinity     `json:"virtualMachineAndPodAffinity,omitempty"`
	VirtualMachineAndPodAntiAffinity *VirtualMachineAndPodAntiAffinity `json:"virtualMachineAndPodAntiAffinity,omitempty"`
}

type VMBDAObjectRef struct {
	// Block device type. Available options:
	// * `VirtualDisk`: Use VirtualDisk as the disk. This type is always mounted in RW mode.
	// * `VirtualImage`: Use VirtualImage as the disk. This type is always mounted in RO mode.
	// * `ClusterVirtualImage`: Use ClusterVirtualImage as the disk. This type is always mounted in RO mode.
	Kind VMBDAObjectRefKind `json:"kind,omitempty"`
	// Name of the block device to attach.
	Name string `json:"name,omitempty"`
}

type VMBDAObjectRefKind string

type VMOPPhase string

type VMOPResourceKind string

type VMOPResourceStatusPhase string

type VMOPRestoreMode string

type VMOPType string

type Versions struct {
	// Qemu is the version of the qemu hypervisor.
	Qemu string `json:"qemu,omitempty"`
	// Libvirt is the version of the libvirt.
	Libvirt string `json:"libvirt,omitempty"`
}

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

	Spec   VirtualDiskSpec   `json:"spec"`
	Status VirtualDiskStatus `json:"status,omitempty"`
}

type VirtualDiskContainerImage struct {
	// Path to the image in the container registry.
	// +kubebuilder:example:="registry.example.com/images/slackware:15"
	// +kubebuilder:validation:Pattern:=`^(?P<name>(?:(?P<domain>(?:(?:localhost|[\w-]+(?:\.[\w-]+)+)(?::\d+)?)|[\w]+:\d+)/)?(?P<image>[a-z0-9_.-]+(?:/[a-z0-9_.-]+)*))(?::(?P<tag>[\w][\w.-]{0,127}))?(?:@(?P<digest>[A-Za-z][A-Za-z0-9]*(?:[+.-_][A-Za-z][A-Za-z0-9]*)*:[0-9a-fA-F]{32,}))?$`
	Image           string              `json:"image"`
	ImagePullSecret ImagePullSecretName `json:"imagePullSecret,omitempty"`
	// CA chain in Base64 format to verify the container registry.
	// +kubebuilder:example:="YWFhCg=="
	CABundle []byte `json:"caBundle,omitempty"`
}

type VirtualDiskDataSource struct {
	Type           DataSourceType             `json:"type,omitempty"`
	HTTP           *DataSourceHTTP            `json:"http,omitempty"`
	ContainerImage *VirtualDiskContainerImage `json:"containerImage,omitempty"`
	ObjectRef      *VirtualDiskObjectRef      `json:"objectRef,omitempty"`
}

type VirtualDiskList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`
	Items           []VirtualDisk `json:"items"`
}

type VirtualDiskObjectRef struct {
	// Kind of the existing VirtualImage, ClusterVirtualImage, or VirtualDiskSnapshot resource.
	Kind VirtualDiskObjectRefKind `json:"kind"`
	// Name of the existing VirtualImage, ClusterVirtualImage, or VirtualDiskSnapshot resource.
	Name string `json:"name"`
}

type VirtualDiskObjectRefKind string

type VirtualDiskPersistentVolumeClaim struct {
	// StorageClass name required by the claim. For details on using StorageClass for PVC, refer to https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1.
	//
	// When creating disks, the user can specify the required StorageClass. If not specified, the default StorageClass will be used.
	//
	// The disk features and virtual machine behavior depend on the selected StorageClass.
	//
	// The `VolumeBindingMode` parameter in the StorageClass affects the disk creation process. The following values are allowed:
	// - `Immediate`: The disk will be created and becomes available for use immediately after creation.
	// - `WaitForFirstConsumer`: The disk will be created when first used on the node where the virtual machine will be started.
	//
	// StorageClass supports multiple storage settings:
	// - Creating a block device (`Block`) or file system (`FileSystem`).
	// - Multiple access (`ReadWriteMany`) or single access (`ReadWriteOnce`). The `ReadWriteMany` disks support multiple access, which enables a "live" migration of virtual machines. In contrast, the `ReadWriteOnce` disks, which can be accessed from only one node, don't have this feature.
	//
	// For known storage types, Deckhouse automatically determines the most efficient settings when creating disks (by priority, in descending order):
	// 1. `Block` + `ReadWriteMany`
	// 2. `FileSystem` + `ReadWriteMany`
	// 3. `Block` + `ReadWriteOnce`
	// 4. `FileSystem` + `ReadWriteOnce`
	StorageClass *string `json:"storageClassName,omitempty"`
	// Desired size for PVC to store the disk. If the disk is created from an image, the size must be at least as large as the original unpacked image.
	//
	// This parameter can be omitted if the `.spec.dataSource` section is filled out. In this case, the controller will determine the disk size automatically, based on the size of the extracted image from the source specified in `.spec.dataSource`.
	Size *resource.Quantity `json:"size,omitempty"`
}

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

	Spec   VirtualDiskSnapshotSpec   `json:"spec"`
	Status VirtualDiskSnapshotStatus `json:"status,omitempty"`
}

type VirtualDiskSnapshotList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`
	Items           []VirtualDiskSnapshot `json:"items"`
}

type VirtualDiskSnapshotPhase string

type VirtualDiskSnapshotSpec struct {
	VirtualDiskName     string `json:"virtualDiskName"`
	RequiredConsistency bool   `json:"requiredConsistency"`
}

type VirtualDiskSnapshotStatus struct {
	Phase              VirtualDiskSnapshotPhase `json:"phase"`
	VolumeSnapshotName string                   `json:"volumeSnapshotName,omitempty"`
	Consistent         *bool                    `json:"consistent,omitempty"`
	Conditions         []metav1.Condition       `json:"conditions,omitempty"`
	ObservedGeneration int64                    `json:"observedGeneration,omitempty"`
}

type VirtualDiskSpec struct {
	DataSource            *VirtualDiskDataSource           `json:"dataSource,omitempty"`
	PersistentVolumeClaim VirtualDiskPersistentVolumeClaim `json:"persistentVolumeClaim,omitempty"`
}

type VirtualDiskStats struct {
	// Waiting time for the virtual disk creation.
	CreationDuration VirtualDiskStatsCreationDuration `json:"creationDuration,omitempty"`
}

type VirtualDiskStatsCreationDuration struct {
	// Waiting time for dependent resources.
	// +nullable
	WaitingForDependencies *metav1.Duration `json:"waitingForDependencies,omitempty"`
	// Duration of the loading into DVCR.
	// +nullable
	DVCRProvisioning *metav1.Duration `json:"dvcrProvisioning,omitempty"`
	// Duration of the resource creation from the moment dependencies are ready until the resource transitions to the Ready state.
	// +nullable
	TotalProvisioning *metav1.Duration `json:"totalProvisioning,omitempty"`
}

type VirtualDiskStatus struct {
	DownloadSpeed *StatusSpeed `json:"downloadSpeed,omitempty"`
	// Requested PVC capacity in human-readable format.
	// +kubebuilder:example:="50G"
	Capacity string     `json:"capacity,omitempty"`
	Target   DiskTarget `json:"target,omitempty"`
	// Progress of copying an image from a source to PVC. Appears only during the `Provisioning' phase.
	Progress string `json:"progress,omitempty"`
	// Deprecated. Use `ImageUploadURLs` instead.
	UploadCommand   string           `json:"uploadCommand,omitempty"`
	ImageUploadURLs *ImageUploadURLs `json:"imageUploadURLs,omitempty"`
	Phase           DiskPhase        `json:"phase,omitempty"`
	// List of VirtualMachines that use the disk.
	// +kubebuilder:example:={{name: VM100}}
	AttachedToVirtualMachines []AttachedVirtualMachine `json:"attachedToVirtualMachines,omitempty"`
	Stats                     VirtualDiskStats         `json:"stats,omitempty"`
	SourceUID                 *types.UID               `json:"sourceUID,omitempty"`
	// The latest available observations of an object's current state.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
	// Resource generation last processed by the controller.
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
	// Name of the StorageClass used by the PersistentVolumeClaim if `Kubernetes` storage type is used.
	StorageClassName string `json:"storageClassName,omitempty"`
}

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

	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec VirtualImageSpec `json:"spec"`

	Status VirtualImageStatus `json:"status,omitempty"`
}

type VirtualImageContainerImage struct {
	// Path to the image in the container registry.
	// +kubebuilder:example:="registry.example.com/images/slackware:15"
	// +kubebuilder:validation:Pattern:=`^(?P<name>(?:(?P<domain>(?:(?:localhost|[\w-]+(?:\.[\w-]+)+)(?::\d+)?)|[\w]+:\d+)/)?(?P<image>[a-z0-9_.-]+(?:/[a-z0-9_.-]+)*))(?::(?P<tag>[\w][\w.-]{0,127}))?(?:@(?P<digest>[A-Za-z][A-Za-z0-9]*(?:[+.-_][A-Za-z][A-Za-z0-9]*)*:[0-9a-fA-F]{32,}))?$`
	Image           string              `json:"image"`
	ImagePullSecret ImagePullSecretName `json:"imagePullSecret,omitempty"`
	// CA chain in Base64 format to verify the container registry.
	// +kubebuilder:example:="YWFhCg=="
	CABundle []byte `json:"caBundle,omitempty"`
}

type VirtualImageDataSource struct {
	Type           DataSourceType              `json:"type,omitempty"`
	HTTP           *DataSourceHTTP             `json:"http,omitempty"`
	ContainerImage *VirtualImageContainerImage `json:"containerImage,omitempty"`
	ObjectRef      *VirtualImageObjectRef      `json:"objectRef,omitempty"`
}

type VirtualImageList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`

	// Items provides a list of CDIs.
	Items []VirtualImage `json:"items"`
}

type VirtualImageObjectRef struct {
	// Kind of an existing VirtualImage, ClusterVirtualImage, VirtualDisk or VirtualDiskSnapshot resource.
	Kind VirtualImageObjectRefKind `json:"kind"`
	// Name of an existing VirtualImage, ClusterVirtualImage, VirtualDisk or VirtualDiskSnapshot resource.
	Name string `json:"name"`
}

type VirtualImageObjectRefKind string

type VirtualImagePersistentVolumeClaim struct {
	// Name of the StorageClass required by the claim. For details on using StorageClass for PVC, refer to — https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1.
	//
	// When creating an image with the `PersistentVolumeClaim` storage type, the user can specify the required StorageClass. If not specified, the default StorageClass will be used.
	StorageClass *string `json:"storageClassName,omitempty"`
}

type VirtualImageSpec struct {
	// +kubebuilder:default:=ContainerRegistry
	Storage               StorageType                       `json:"storage"`
	PersistentVolumeClaim VirtualImagePersistentVolumeClaim `json:"persistentVolumeClaim,omitempty"`
	DataSource            VirtualImageDataSource            `json:"dataSource"`
}

type VirtualImageStatus struct {
	// Image download speed from an external source. Appears only during the `Provisioning` phase.
	DownloadSpeed *StatusSpeed `json:"downloadSpeed,omitempty"`
	// Discovered image size data.
	Size ImageStatusSize `json:"size,omitempty"`
	// Discovered image format.
	Format string `json:"format,omitempty"`
	// Whether the image is in a format that needs to be mounted as a CD-ROM drive, such as iso and so on.
	CDROM bool `json:"cdrom,omitempty"`
	// Current status of the ClusterVirtualImage resource:
	// * `Pending`: The resource has been created and is on a waiting queue.
	// * `Provisioning`: The resource is being created: copying, downloading, or building the image.
	// * `WaitForUserUpload`: Waiting for the user to upload the image. The endpoint to upload the image is specified in `.status.uploadCommand`.
	// * `Ready`: The resource has been created and is ready to use.
	// * `Failed`: There was an error when creating the resource.
	// * `Terminating`: The resource is being deleted.
	// * `PVCLost`: The child PVC of the resource is missing. The resource cannot be used.
	// +kubebuilder:validation:Enum:={Pending,Provisioning,WaitForUserUpload,Ready,Failed,Terminating,PVCLost}
	Phase ImagePhase `json:"phase,omitempty"`
	// Progress of copying an image from a source to DVCR.
	Progress string `json:"progress,omitempty"`
	// Deprecated. Use `imageUploadURLs` instead.
	UploadCommand   string                   `json:"uploadCommand,omitempty"`
	ImageUploadURLs *ImageUploadURLs         `json:"imageUploadURLs,omitempty"`
	Target          VirtualImageStatusTarget `json:"target,omitempty"`
	// UID of the source (VirtualImage, ClusterVirtualImage, VirtualDisk or VirtualDiskSnapshot) used when creating the virtual image.
	SourceUID *types.UID `json:"sourceUID,omitempty"`
	// The latest available observations of an object's current state.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
	// Resource generation last processed by the controller.
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
	// Name of the StorageClass used by the PersistentVolumeClaim if `Kubernetes` storage type is used.
	StorageClassName string `json:"storageClassName,omitempty"`
}

type VirtualImageStatusTarget struct {
	// Created image in DVCR.
	// +kubebuilder:example:="dvcr.<dvcr-namespace>.svc/vi/<image-namespace>/<image-name>:latest"
	RegistryURL string `json:"registryURL,omitempty"`
	// Created PersistentVolumeClaim name for the PersistentVolumeClaim storage.
	PersistentVolumeClaim string `json:"persistentVolumeClaimName,omitempty"`
}

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

	Spec   VirtualMachineSpec   `json:"spec"`
	Status VirtualMachineStatus `json:"status,omitempty"`
}

type VirtualMachineAndPodAffinity struct {
	RequiredDuringSchedulingIgnoredDuringExecution  []VirtualMachineAndPodAffinityTerm         `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty"`
	PreferredDuringSchedulingIgnoredDuringExecution []WeightedVirtualMachineAndPodAffinityTerm `json:"preferredDuringSchedulingIgnoredDuringExecution,omitempty"`
}

type VirtualMachineAndPodAffinityTerm struct {
	LabelSelector     *metav1.LabelSelector `json:"labelSelector,omitempty"`
	Namespaces        []string              `json:"namespaces,omitempty"`
	TopologyKey       string                `json:"topologyKey"`
	NamespaceSelector *metav1.LabelSelector `json:"namespaceSelector,omitempty"`
	MatchLabelKeys    []string              `json:"matchLabelKeys,omitempty"`
	MismatchLabelKeys []string              `json:"mismatchLabelKeys,omitempty"`
}

type VirtualMachineAndPodAntiAffinity struct {
	RequiredDuringSchedulingIgnoredDuringExecution  []VirtualMachineAndPodAffinityTerm         `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty"`
	PreferredDuringSchedulingIgnoredDuringExecution []WeightedVirtualMachineAndPodAffinityTerm `json:"preferredDuringSchedulingIgnoredDuringExecution,omitempty"`
}

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

	Spec   VirtualMachineBlockDeviceAttachmentSpec   `json:"spec"`
	Status VirtualMachineBlockDeviceAttachmentStatus `json:"status,omitempty"`
}

type VirtualMachineBlockDeviceAttachmentList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`

	// Items provides a list of CDIs.
	Items []VirtualMachineBlockDeviceAttachment `json:"items"`
}

type VirtualMachineBlockDeviceAttachmentSpec struct {
	// Virtual machine name the disk or image should be attached to.
	VirtualMachineName string         `json:"virtualMachineName"`
	BlockDeviceRef     VMBDAObjectRef `json:"blockDeviceRef"`
}

type VirtualMachineBlockDeviceAttachmentStatus struct {
	Phase BlockDeviceAttachmentPhase `json:"phase,omitempty"`
	// Name of the virtual machine the disk is attached to.
	VirtualMachineName string `json:"virtualMachineName,omitempty"`
	// Contains details of the current API resource state.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
	// Resource generation last processed by the controller.
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
}

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

	Spec   VirtualMachineClassSpec   `json:"spec"`
	Status VirtualMachineClassStatus `json:"status,omitempty"`
}

type VirtualMachineClassList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`

	// Items provides a list of VirtualMachineClasses.
	Items []VirtualMachineClass `json:"items"`
}

type VirtualMachineClassPhase string

type VirtualMachineClassSpec struct {
	NodeSelector NodeSelector `json:"nodeSelector,omitempty"`
	// Tolerations are the same as `spec.tolerations` for [pods](https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/).
	// These tolerations will be merged with the tolerations specified in the VirtualMachine resource. VirtualMachine tolerations have a higher priority.
	Tolerations []corev1.Toleration `json:"tolerations,omitempty"`
	// +kubebuilder:validation:Required
	CPU            CPU            `json:"cpu"`
	SizingPolicies []SizingPolicy `json:"sizingPolicies,omitempty"`
}

type VirtualMachineClassStatus struct {
	Phase       VirtualMachineClassPhase `json:"phase"`
	CpuFeatures CpuFeatures              `json:"cpuFeatures,omitempty"`
	// List of nodes that support this CPU model.
	// It is not displayed for the following types: `Host`, `HostPassthrough`.
	//
	// +kubebuilder:example={node-1, node-2}
	AvailableNodes []string `json:"availableNodes,omitempty"`
	// Maximum amount of free CPU and memory resources observed among all available nodes.
	// +kubebuilder:example={"maxAllocatableResources: {\"cpu\": 1, \"memory\": \"10Gi\"}"}
	MaxAllocatableResources corev1.ResourceList `json:"maxAllocatableResources,omitempty"`
	// The latest detailed observations of the VirtualMachineClass resource.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
	// Resource generation last processed by the controller.
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
}

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

	Spec   VirtualMachineIPAddressSpec   `json:"spec,omitempty"`
	Status VirtualMachineIPAddressStatus `json:"status,omitempty"`
}

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

	Spec   VirtualMachineIPAddressLeaseSpec   `json:"spec,omitempty"`
	Status VirtualMachineIPAddressLeaseStatus `json:"status,omitempty"`
}

type VirtualMachineIPAddressLeaseIpAddressRef struct {
	// The Namespace of the referenced `VirtualMachineIPAddress`.
	Namespace string `json:"namespace"`
	// The name of the referenced `VirtualMachineIPAddress`.
	Name string `json:"name"`
}

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

type VirtualMachineIPAddressLeasePhase string

type VirtualMachineIPAddressLeaseSpec struct {
	// The link to existing `VirtualMachineIPAddress`.
	VirtualMachineIPAddressRef *VirtualMachineIPAddressLeaseIpAddressRef `json:"virtualMachineIPAddressRef,omitempty"`
}

type VirtualMachineIPAddressLeaseStatus struct {
	// Represents the current state of issued IP address lease.
	Phase              VirtualMachineIPAddressLeasePhase `json:"phase,omitempty"`
	ObservedGeneration int64                             `json:"observedGeneration,omitempty"`
	Conditions         []metav1.Condition                `json:"conditions,omitempty"`
}

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

type VirtualMachineIPAddressPhase string

type VirtualMachineIPAddressSpec struct {
	// Type specifies the mode of IP address assignment. Possible values are "Auto" for automatic IP assignment,
	// or "Static" for assigning a specific IP address.
	Type VirtualMachineIPAddressType `json:"type"`
	// StaticIP is the requested IP address. If omitted the next available IP address will be assigned.
	StaticIP string `json:"staticIP,omitempty"`
}

type VirtualMachineIPAddressStatus struct {
	// VirtualMachine represents the virtual machine that currently uses this IP address.
	// It's the name of the virtual machine instance.
	VirtualMachine string `json:"virtualMachineName,omitempty"`

	// Address is the assigned IP address allocated to the virtual machine.
	Address string `json:"address,omitempty"`

	// Phase represents the current state of the IP address.
	// It could indicate whether the IP address is in use, available, or in any other defined state.
	Phase VirtualMachineIPAddressPhase `json:"phase,omitempty"`

	// ObservedGeneration is the most recent generation observed by the controller.
	// This is used to identify changes that have been recently observed and handled.
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// Conditions represents the latest available observations of the object's state.
	// They provide detailed status and information, such as whether the IP address allocation was successful, in progress, etc.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type VirtualMachineIPAddressType string

type VirtualMachineLaunchTimeDuration struct {
	// The waiting time for dependent resources. pending -> starting.
	// +nullable
	WaitingForDependencies *metav1.Duration `json:"waitingForDependencies,omitempty"`
	// The waiting time for the virtual machine to start. starting -> running.
	// +nullable
	VirtualMachineStarting *metav1.Duration `json:"virtualMachineStarting,omitempty"`
	// The waiting time for the guestOsAgent to start. running -> running with guestOSAgent.
	// +nullable
	GuestOSAgentStarting *metav1.Duration `json:"guestOSAgentStarting,omitempty"`
}

type VirtualMachineList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`

	// Items provides a list of VirtualMachines
	Items []VirtualMachine `json:"items"`
}

type VirtualMachineLocation struct {
	// The name of the node on which the VM is currently migrating.
	Node string `json:"node,omitempty"`
	// The name of the pod where the VM is currently being migrated.
	Pod string `json:"pod,omitempty"`
}

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

	Spec   VirtualMachineMACAddressSpec   `json:"spec,omitempty"`
	Status VirtualMachineMACAddressStatus `json:"status,omitempty"`
}

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

	Spec   VirtualMachineMACAddressLeaseSpec   `json:"spec,omitempty"`
	Status VirtualMachineMACAddressLeaseStatus `json:"status,omitempty"`
}

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

type VirtualMachineMACAddressLeaseMACAddressRef struct {
	// The Namespace of the referenced `VirtualMachineMACAddress`.
	Namespace string `json:"namespace"`
	// The name of the referenced `VirtualMachineMACAddress`.
	Name string `json:"name"`
}

type VirtualMachineMACAddressLeasePhase string

type VirtualMachineMACAddressLeaseSpec struct {
	// The link to existing `VirtualMachineMACAddress`.
	VirtualMachineMACAddressRef *VirtualMachineMACAddressLeaseMACAddressRef `json:"virtualMachineMACAddressRef,omitempty"`
}

type VirtualMachineMACAddressLeaseStatus struct {
	// Represents the current state of issued MAC address lease.
	Phase              VirtualMachineMACAddressLeasePhase `json:"phase,omitempty"`
	ObservedGeneration int64                              `json:"observedGeneration,omitempty"`
	Conditions         []metav1.Condition                 `json:"conditions,omitempty"`
}

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

type VirtualMachineMACAddressPhase string

type VirtualMachineMACAddressSpec struct {
	// MACAddress is the requested MAC address. If omitted - random generate.
	Address string `json:"address,omitempty"`
}

type VirtualMachineMACAddressStatus struct {
	// VirtualMachine represents the virtual machine that currently uses this MAC address.
	// It's the name of the virtual machine instance.
	VirtualMachine string `json:"virtualMachineName,omitempty"`

	// Address is the assigned MAC address allocated to the virtual machine.
	Address string `json:"address,omitempty"`

	// Phase represents the current state of the MAC address.
	// It could indicate whether the MAC address is in use, available, or in any other defined state.
	Phase VirtualMachineMACAddressPhase `json:"phase,omitempty"`

	// ObservedGeneration is the most recent generation observed by the controller.
	// This is used to identify changes that have been recently observed and handled.
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// Conditions represents the latest available observations of the object's state.
	// They provide detailed status and information, such as whether the MAC address allocation was successful, in progress, etc.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type VirtualMachineMigrationState struct {
	// Migration start time.
	StartTimestamp *metav1.Time `json:"startTimestamp,omitempty"`
	// Migration end time.
	EndTimestamp *metav1.Time           `json:"endTimestamp,omitempty"`
	Target       VirtualMachineLocation `json:"target,omitempty"`
	Source       VirtualMachineLocation `json:"source,omitempty"`
	Result       MigrationResult        `json:"result,omitempty"`
}

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

	Spec   VirtualMachineOperationSpec   `json:"spec"`
	Status VirtualMachineOperationStatus `json:"status,omitempty"`
}

type VirtualMachineOperationList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`
	Items           []VirtualMachineOperation `json:"items"`
}

type VirtualMachineOperationResource struct {
	// API version of the resource.
	APIVersion string `json:"apiVersion"`
	// Name of the resource.
	Name string `json:"name"`
	// Kind of the resource.
	Kind string `json:"kind"`
	// Status of the resource.
	Status VMOPResourceStatusPhase `json:"status"`
	// Message about the resource.
	Message string `json:"message"`
}

type VirtualMachineOperationRestoreSpec struct {
	Mode VMOPRestoreMode `json:"mode"`
	// VirtualMachineSnapshotName defines the source of the restore operation.
	VirtualMachineSnapshotName string `json:"virtualMachineSnapshotName"`
}

type VirtualMachineOperationSpec struct {
	Type VMOPType `json:"type"`
	// Name of the virtual machine the operation is performed for.
	VirtualMachine string `json:"virtualMachineName"`
	// Force execution of an operation.
	//
	// * Effect on `Restart` and `Stop`: operation performs immediately.
	// * Effect on `Evict` and `Migrate`: enable the AutoConverge feature to force migration via CPU throttling if the `PreferSafe` or `PreferForced` policies are used for live migration.
	Force *bool `json:"force,omitempty"`
	// Restore defines the restore operation.
	Restore *VirtualMachineOperationRestoreSpec `json:"restore,omitempty"`
}

type VirtualMachineOperationStatus struct {
	Phase VMOPPhase `json:"phase"`
	// The latest detailed observations of the VirtualMachineOperation resource.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
	//  Resource generation last processed by the controller.
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
	// Resources contains the list of resources that are affected by the snapshot operation.
	Resources []VirtualMachineOperationResource `json:"resources,omitempty"`
}

type VirtualMachinePhaseTransitionTimestamp struct {
	Phase MachinePhase `json:"phase,omitempty"`
	// PhaseTransitionTimestamp is the timestamp of when the phase change occurred
	// +kubebuilder:validation:Format:=date-time
	// +nullable
	Timestamp metav1.Time `json:"timestamp,omitempty"`
}

type VirtualMachinePod struct {
	// Name of virtual machine pod.
	Name string `json:"name"`
	// Current working pod.
	Active bool `json:"active"`
}

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

	Spec   VirtualMachineRestoreSpec   `json:"spec"`
	Status VirtualMachineRestoreStatus `json:"status,omitempty"`
}

type VirtualMachineRestoreList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`
	Items           []VirtualMachineRestore `json:"items"`
}

type VirtualMachineRestorePhase string

type VirtualMachineRestoreSpec struct {
	// Virtual machine restore mode:
	//
	// * Safe — in this mode, the virtual machine will not be restored if unresolvable conflicts are detected during the restoration process.
	// * Forced — in this mode, the virtual machine configuration will be updated and all associated resources will be recreated. The virtual machine may malfunction if the recovery process fails. Use the mode when you need to restore the virtual machine despite conflicts.
	// +kubebuilder:validation:Optional
	// +kubebuilder:validation:Enum=Safe;Forced
	// +kubebuilder:default:=Safe
	RestoreMode RestoreMode `json:"restoreMode,omitempty"`
	// Snapshot name to restore a virtual machine from.
	//
	// +kubebuilder:validation:MinLength=1
	VirtualMachineSnapshotName string `json:"virtualMachineSnapshotName"`
	// Renaming conventions for virtual machine resources.
	NameReplacements []NameReplacement `json:"nameReplacements,omitempty"`
}

type VirtualMachineRestoreStatus struct {
	Phase VirtualMachineRestorePhase `json:"phase"`
	// Contains details of the current API resource state.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
	// Resource generation last processed by the controller.
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
}

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

	Spec   VirtualMachineSnapshotSpec   `json:"spec"`
	Status VirtualMachineSnapshotStatus `json:"status,omitempty"`
}

type VirtualMachineSnapshotList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`
	Items           []VirtualMachineSnapshot `json:"items"`
}

type VirtualMachineSnapshotPhase string

type VirtualMachineSnapshotSpec struct {
	// Name of the virtual machine to take a snapshot of.
	//
	// +kubebuilder:validation:MinLength=1
	VirtualMachineName string `json:"virtualMachineName"`
	// Create a snapshot of a virtual machine only if it is possible to freeze the machine through the agent.
	//
	// If set to `true`, the virtual machine snapshot will be created only in the following cases:
	// - When the virtual machine is powered off.
	// - When the virtual machine has an agent, and the freeze operation was successful.
	//
	// +kubebuilder:default:=true
	RequiredConsistency bool `json:"requiredConsistency"`
	// +kubebuilder:default:="Always"
	KeepIPAddress KeepIPAddress `json:"keepIPAddress"`
}

type VirtualMachineSnapshotStatus struct {
	Phase VirtualMachineSnapshotPhase `json:"phase"`
	// Whether a virtual machine snapshot is consistent.
	Consistent *bool `json:"consistent,omitempty"`
	// Name of the underlying `Secret` created for virtual machine snapshotting.
	VirtualMachineSnapshotSecretName string `json:"virtualMachineSnapshotSecretName,omitempty"`
	// List of VirtualDiskSnapshot names for the snapshots taken from the virtual disks of the associated virtual machine.
	VirtualDiskSnapshotNames []string `json:"virtualDiskSnapshotNames,omitempty"`
	// List of snapshot resources.
	Resources []ResourceRef `json:"resources,omitempty"`
	// The latest detailed observations of the VirtualMachineSnapshot resource.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
	// Resource generation last processed by the controller.
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
}

type VirtualMachineSpec struct {
	// +kubebuilder:default:="AlwaysOnUnlessStoppedManually"
	RunPolicy RunPolicy `json:"runPolicy,omitempty"`

	// Name for the associated `virtualMachineIPAddress` resource.
	// Specified when it is necessary to use a previously created IP address of the VM.
	// If not explicitly specified, by default a `virtualMachineIPAddress` resource is created for the VM with a name similar to the VM resource (`.metadata.name`).
	VirtualMachineIPAddress string `json:"virtualMachineIPAddressName,omitempty"`

	TopologySpreadConstraints []corev1.TopologySpreadConstraint `json:"topologySpreadConstraints,omitempty"`

	Affinity *VMAffinity `json:"affinity,omitempty"`

	// NodeSelector must match a node's labels for the VM to be scheduled on that node.
	// [The same](https://kubernetes.io/docs/tasks/configure-pod-container/assign-pods-nodes//) as in the pods `spec.nodeSelector` parameter in Kubernetes.
	NodeSelector map[string]string `json:"nodeSelector,omitempty"`

	// PriorityClassName [The same](https://kubernetes.io/docs/concepts/scheduling-eviction/pod-priority-preemption/)  as in the pods `spec.priorityClassName` parameter in Kubernetes.
	PriorityClassName string `json:"priorityClassName,omitempty"`

	// Tolerations define rules to tolerate node taints.
	// The same](https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/) as in the pods `spec.tolerations` parameter in Kubernetes.
	Tolerations []corev1.Toleration `json:"tolerations,omitempty"`

	// +kubebuilder:default:={"restartApprovalMode": "Manual"}
	Disruptions *Disruptions `json:"disruptions,omitempty"`

	// Grace period observed after signalling a VM to stop after which the VM is force terminated.
	// +kubebuilder:default:=60
	TerminationGracePeriodSeconds *int64 `json:"terminationGracePeriodSeconds,omitempty"`

	// Use the `virtio` bus to connect virtual devices of the VM. Set false to disable `virtio` for this VM.
	// Note: To use paravirtualization mode, some operating systems require the appropriate drivers to be installed.
	// +kubebuilder:default:=true
	EnableParavirtualization bool `json:"enableParavirtualization,omitempty"`

	// +kubebuilder:default:="Generic"
	OsType OsType `json:"osType,omitempty"`
	// +kubebuilder:default:="BIOS"
	Bootloader BootloaderType `json:"bootloader,omitempty"`
	// Name of the `VirtualMachineClass` resource describing the requirements for a virtual CPU, memory and the resource allocation policy and node placement policies for virtual machines.
	VirtualMachineClassName string     `json:"virtualMachineClassName"`
	CPU                     CPUSpec    `json:"cpu"`
	Memory                  MemorySpec `json:"memory"`
	// List of block devices that can be mounted by disks belonging to the virtual machine.
	// The order of booting is determined by the order in the list.
	// +kubebuilder:validation:MinItems:=1
	// +kubebuilder:validation:MaxItems:=16
	BlockDeviceRefs []BlockDeviceSpecRef `json:"blockDeviceRefs"`
	Provisioning    *Provisioning        `json:"provisioning,omitempty"`

	// Live migration policy type.
	LiveMigrationPolicy LiveMigrationPolicy `json:"liveMigrationPolicy"`
	Networks            []NetworksSpec      `json:"networks,omitempty"`
}

type VirtualMachineStats struct {
	// The history of phases.
	PhasesTransitions []VirtualMachinePhaseTransitionTimestamp `json:"phasesTransitions,omitempty"`
	// Launch information.
	LaunchTimeDuration VirtualMachineLaunchTimeDuration `json:"launchTimeDuration,omitempty"`
}

type VirtualMachineStatus struct {
	Phase MachinePhase `json:"phase"`
	// The name of the node on which the VM is currently running.
	Node string `json:"nodeName"`
	// Name of `virtualMachineIPAddressName` holding the ip address of the VirtualMachine.
	VirtualMachineIPAddress string `json:"virtualMachineIPAddressName"`
	// IP address of VM.
	IPAddress string `json:"ipAddress"`
	// The list of attached block device attachments.
	BlockDeviceRefs []BlockDeviceStatusRef                   `json:"blockDeviceRefs,omitempty"`
	GuestOSInfo     virtv1.VirtualMachineInstanceGuestOSInfo `json:"guestOSInfo,omitempty"`
	// Detailed state of the virtual machine lifecycle.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
	// VirtualMachine statistics.
	Stats *VirtualMachineStats `json:"stats,omitempty"`
	// Migration info.
	MigrationState *VirtualMachineMigrationState `json:"migrationState,omitempty"`
	// Generating a resource that was last processed by the controller.
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// RestartAwaitingChanges holds operations to be manually approved before applying to the virtual machine spec.
	RestartAwaitingChanges []apiextensionsv1.JSON `json:"restartAwaitingChanges,omitempty"`
	// List of virtual machine pods.
	VirtualMachinePods []VirtualMachinePod `json:"virtualMachinePods,omitempty"`
	// Hypervisor versions.
	Versions  Versions         `json:"versions,omitempty"`
	Resources ResourcesStatus  `json:"resources,omitempty"`
	Networks  []NetworksStatus `json:"networks,omitempty"`
}

type WeightedVirtualMachineAndPodAffinityTerm struct {
	// weight associated with matching the corresponding vmAndPodAffinityTerm,
	// in the range 1-100.
	Weight int32 `json:"weight"`
	// Required. A vm affinity term, associated with the corresponding weight.
	VirtualMachineAndPodAffinityTerm VirtualMachineAndPodAffinityTerm `json:"virtualMachineAndPodAffinityTerm"`
}