v1alpha3

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

	Spec   VirtualMachineImageSpec   `json:"spec,omitempty"`
	Status VirtualMachineImageStatus `json:"status,omitempty"`
}

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

type DynamicDirectPathIODevice struct {
	VendorID int64 `json:"vendorID"`
	DeviceID int64 `json:"deviceID"`

	CustomLabel string `json:"customLabel,omitempty"`
}

type GuestHeartbeatAction struct {

	// ThresholdStatus is the value that the guest heartbeat status must be at or above to be
	// considered successful.
	ThresholdStatus GuestHeartbeatStatus `json:"thresholdStatus,omitempty"`
}

type GuestHeartbeatStatus string

type GuestInfoAction struct {
	// Key is the name of the GuestInfo key.
	//
	// The key is automatically prefixed with "guestinfo." before being
	// evaluated. Thus if the key "guestinfo.mykey" is provided, it will be
	// evaluated as "guestinfo.guestinfo.mykey".
	Key string `json:"key"`

	// Value is a regular expression that is matched against the value of the
	// specified key.
	//
	// An empty value is the equivalent of "match any" or ".*".
	//
	// All values must adhere to the RE2 regular expression syntax as documented
	// at https://golang.org/s/re2syntax. Invalid values may be rejected or
	// ignored depending on the implementation of this API. Either way, invalid
	// values will not be considered when evaluating the ready state of a VM.
	Value string `json:"value,omitempty"`
}

type InstanceStorage struct {
	// StorageClass refers to the name of a StorageClass resource used to
	// provide the storage for the configured instance storage volumes.
	// The value of this field has no relationship to or bearing on the field
	// virtualMachine.spec.storageClass. Please note the referred StorageClass
	// must be available in the same namespace as the VirtualMachineClass that
	// uses it for configuring instance storage.
	StorageClass string `json:"storageClass,omitempty"`

	// Volumes describes instance storage volumes created for a VirtualMachine
	// instance that use this VirtualMachineClass.
	Volumes []InstanceStorageVolume `json:"volumes,omitempty"`
}

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

type InstanceVolumeClaimVolumeSource struct {
	// StorageClass is the name of the Kubernetes StorageClass that provides
	// the backing storage for this instance storage volume.
	StorageClass string `json:"storageClass"`

	// Size is the size of the requested instance storage volume.
	Size resource.Quantity `json:"size"`
}

type LoadBalancerIngress struct {

	// IP is set for load balancer ingress points that are specified by an IP
	// address.
	IP string `json:"ip,omitempty"`

	// Hostname is set for load balancer ingress points that are specified by a
	// DNS address.
	Hostname string `json:"hostname,omitempty"`
}

type LoadBalancerStatus struct {

	// Ingress is a list containing ingress addresses for the load balancer.
	// Traffic intended for the service should be sent to any of these ingress
	// points.
	Ingress []LoadBalancerIngress `json:"ingress,omitempty"`
}

type NetworkDeviceStatus struct {

	// Gateway4 is the gateway for the IPv4 address family for this device.
	Gateway4 string

	// MacAddress is the MAC address of the network device.
	MacAddress string

	// IpAddresses represents one or more IP addresses assigned to the network
	// device in CIDR notation, ex. "192.0.2.1/16".
	IPAddresses []string
}

type NetworkStatus struct {

	// Devices describe a list of current status information for each
	// network interface that is desired to be attached to the
	// VirtualMachineTemplate.
	Devices []NetworkDeviceStatus

	// Nameservers describe a list of the DNS servers accessible by one of the
	// VM's configured network devices.
	Nameservers []string
}

type OVFProperty struct {
	// Key describes the OVF property's key.
	Key string `json:"key"`

	// Type describes the OVF property's type.
	Type string `json:"type"`

	// Default describes the OVF property's default value.
	Default *string `json:"default,omitempty"`
}

type PersistentVolumeClaimVolumeSource struct {
	corev1.PersistentVolumeClaimVolumeSource `json:",inline" yaml:",inline"`

	// InstanceVolumeClaim is set if the PVC is backed by instance storage.
	InstanceVolumeClaim *InstanceVolumeClaimVolumeSource `json:"instanceVolumeClaim,omitempty"`
}

type ResourcePoolSpec struct {

	// Name describes the name of the ResourcePool grouping.
	Name string `json:"name,omitempty"`

	// Reservations describes the guaranteed resources reserved for the
	// ResourcePool.
	Reservations VirtualMachineResourceSpec `json:"reservations,omitempty"`

	// Limits describes the limit to resources available to the ResourcePool.
	Limits VirtualMachineResourceSpec `json:"limits,omitempty"`
}

type TCPSocketAction struct {
	// Port specifies a number or name of the port to access on the VM.
	// If the format of port is a number, it must be in the range 1 to 65535.
	// If the format of name is a string, it must be an IANA_SVC_NAME.
	Port intstr.IntOrString `json:"port"`

	// Host is an optional host name to connect to. Host defaults to the VM IP.
	Host string `json:"host,omitempty"`
}

type VGPUDevice struct {
	ProfileName string `json:"profileName"`
}

type VSphereClusterModuleStatus struct {
	GroupName   string `json:"groupName"`
	ModuleUuid  string `json:"moduleUUID"` //nolint:revive,stylecheck
	ClusterMoID string `json:"clusterMoID"`
}

type VirtualDevices struct {
	// +optional
	// +listType=map
	// +listMapKey=profileName
	VGPUDevices []VGPUDevice `json:"vgpuDevices,omitempty"`

	// +optional
	DynamicDirectPathIODevices []DynamicDirectPathIODevice `json:"dynamicDirectPathIODevices,omitempty"`
}

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

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

type VirtualMachineAdvancedSpec struct {

	// BootDiskCapacity is the capacity of the VM's boot disk -- the first disk
	// from the VirtualMachineImage from which the VM was deployed.
	//
	// Please note it is not advised to change this value while the VM is
	// running. Also, resizing the VM's boot disk may require actions inside of
	// the guest to take advantage of the additional capacity. Finally, changing
	// the size of the VM's boot disk, even increasing it, could adversely
	// affect the VM.
	//
	// Please note this field is ignored if the VM is deployed from an ISO with
	// CD-ROM devices attached.
	BootDiskCapacity *resource.Quantity `json:"bootDiskCapacity,omitempty"`

	// DefaultVolumeProvisioningMode specifies the default provisioning mode for
	// persistent volumes managed by this VM.
	DefaultVolumeProvisioningMode VirtualMachineVolumeProvisioningMode `json:"defaultVolumeProvisioningMode,omitempty"`

	// ChangeBlockTracking is a flag that enables incremental backup support
	// for this VM, a feature utilized by external backup systems such as
	// VMware Data Recovery.
	ChangeBlockTracking *bool `json:"changeBlockTracking,omitempty"`
}

type VirtualMachineBootstrapCloudInitSpec struct {

	// InstanceID is the cloud-init metadata instance ID.
	// If omitted, this field defaults to the VM's BiosUUID.
	InstanceID string `json:"instanceID,omitempty"`

	// CloudConfig describes a subset of a Cloud-Init CloudConfig, used to
	// bootstrap the VM.
	//
	// Please note this field and RawCloudConfig are mutually exclusive.
	CloudConfig *vmopv1cloudinit.CloudConfig `json:"cloudConfig,omitempty"`

	// RawCloudConfig describes a key in a Secret resource that contains the
	// CloudConfig data used to bootstrap the VM.
	//
	// The CloudConfig data specified by the key may be plain-text,
	// base64-encoded, or gzipped and base64-encoded.
	//
	// Please note this field and CloudConfig are mutually exclusive.
	RawCloudConfig *vmopv1common.SecretKeySelector `json:"rawCloudConfig,omitempty"`

	// SSHAuthorizedKeys is a list of public keys that CloudInit will apply to
	// the guest's default user.
	SSHAuthorizedKeys []string `json:"sshAuthorizedKeys,omitempty"`

	// UseGlobalNameserversAsDefault will use the global nameservers specified in
	// the NetworkSpec as the per-interface nameservers when the per-interface
	// nameservers is not provided.
	//
	// Defaults to true if omitted.
	UseGlobalNameserversAsDefault *bool `json:"useGlobalNameserversAsDefault,omitempty"`

	// UseGlobalSearchDomainsAsDefault will use the global search domains specified
	// in the NetworkSpec as the per-interface search domains when the per-interface
	// search domains is not provided.
	//
	// Defaults to true if omitted.
	UseGlobalSearchDomainsAsDefault *bool `json:"useGlobalSearchDomainsAsDefault,omitempty"`
}

type VirtualMachineBootstrapLinuxPrepSpec struct {

	// HardwareClockIsUTC specifies whether the hardware clock is in UTC or
	// local time.
	HardwareClockIsUTC *bool `json:"hardwareClockIsUTC,omitempty"`

	// TimeZone is a case-sensitive timezone, such as Europe/Sofia.
	//
	// Valid values are based on the tz (timezone) database used by Linux and
	// other Unix systems. The values are strings in the form of
	// "Area/Location," in which Area is a continent or ocean name, and
	// Location is the city, island, or other regional designation.
	//
	// Please see https://kb.vmware.com/s/article/2145518 for a list of valid
	// time zones for Linux systems.
	TimeZone string `json:"timeZone,omitempty"`
}

type VirtualMachineBootstrapSpec struct {

	// CloudInit may be used to bootstrap Linux guests with Cloud-Init or
	// Windows guests that support Cloudbase-Init.
	//
	// The guest's networking stack is configured by Cloud-Init on Linux guests
	// and Cloudbase-Init on Windows guests.
	//
	// Please note this bootstrap provider may not be used in conjunction with
	// the other bootstrap providers.
	CloudInit *VirtualMachineBootstrapCloudInitSpec `json:"cloudInit,omitempty"`

	// LinuxPrep may be used to bootstrap Linux guests.
	//
	// The guest's networking stack is configured by Guest OS Customization
	// (GOSC).
	//
	// Please note this bootstrap provider may be used in conjunction with the
	// VAppConfig bootstrap provider when wanting to configure the guest's
	// network with GOSC but also send vApp/OVF properties into the guest.
	//
	// This bootstrap provider may not be used in conjunction with the CloudInit
	// or Sysprep bootstrap providers.
	LinuxPrep *VirtualMachineBootstrapLinuxPrepSpec `json:"linuxPrep,omitempty"`

	// Sysprep may be used to bootstrap Windows guests.
	//
	// The guest's networking stack is configured by Guest OS Customization
	// (GOSC).
	//
	// Please note this bootstrap provider may be used in conjunction with the
	// VAppConfig bootstrap provider when wanting to configure the guest's
	// network with GOSC but also send vApp/OVF properties into the guest.
	//
	// This bootstrap provider may not be used in conjunction with the CloudInit
	// or LinuxPrep bootstrap providers.
	Sysprep *VirtualMachineBootstrapSysprepSpec `json:"sysprep,omitempty"`

	// VAppConfig may be used to bootstrap guests that rely on vApp properties
	// (how VMware surfaces OVF properties on guests) to transport data into the
	// guest.
	//
	// The guest's networking stack may be configured using either vApp
	// properties or GOSC.
	//
	// Many OVFs define one or more properties that are used by the guest to
	// bootstrap its networking stack. If the VirtualMachineImage defines one or
	// more properties like this, then they can be configured to use the network
	// data provided for this VM at runtime by setting these properties to Go
	// template strings.
	//
	// It is also possible to use GOSC to bootstrap this VM's network stack by
	// configuring either the LinuxPrep or Sysprep bootstrap providers.
	//
	// Please note the VAppConfig bootstrap provider in conjunction with the
	// LinuxPrep bootstrap provider is the equivalent of setting the v1alpha1
	// VM metadata transport to "OvfEnv".
	//
	// This bootstrap provider may not be used in conjunction with the CloudInit
	// bootstrap provider.
	VAppConfig *VirtualMachineBootstrapVAppConfigSpec `json:"vAppConfig,omitempty"`
}

type VirtualMachineBootstrapSysprepSpec struct {

	// Sysprep is an object representation of a Windows sysprep.xml answer file.
	//
	// This field encloses all the individual keys listed in a sysprep.xml file.
	//
	// For more detailed information please see
	// https://technet.microsoft.com/en-us/library/cc771830(v=ws.10).aspx.
	//
	// Please note this field and RawSysprep are mutually exclusive.
	Sysprep *vmopv1sysprep.Sysprep `json:"sysprep,omitempty"`

	// RawSysprep describes a key in a Secret resource that contains an XML
	// string of the Sysprep text used to bootstrap the VM.
	//
	// The data specified by the Secret key may be plain-text, base64-encoded,
	// or gzipped and base64-encoded.
	//
	// Please note this field and Sysprep are mutually exclusive.
	RawSysprep *vmopv1common.SecretKeySelector `json:"rawSysprep,omitempty"`
}

type VirtualMachineBootstrapVAppConfigSpec struct {

	// Properties is a list of vApp/OVF property key/value pairs.
	//
	// Please note this field and RawProperties are mutually exclusive.
	Properties []vmopv1common.KeyValueOrSecretKeySelectorPair `json:"properties,omitempty"`

	// RawProperties is the name of a Secret resource in the same Namespace as
	// this VM where each key/value pair from the Secret is used as a vApp
	// key/value pair.
	//
	// Please note this field and Properties are mutually exclusive.
	RawProperties string `json:"rawProperties,omitempty"`
}

type VirtualMachineCdromSpec struct {

	// Name consists of at least two lowercase letters or digits of this CD-ROM.
	// It must be unique among all CD-ROM devices attached to the VM.
	//
	// This field is immutable when the VM is powered on.
	Name string `json:"name"`

	// Image describes the reference to an ISO type VirtualMachineImage or
	// ClusterVirtualMachineImage resource used as the backing for the CD-ROM.
	// If the image kind is omitted, it defaults to VirtualMachineImage.
	//
	// This field is immutable when the VM is powered on.
	//
	// Please note, unlike the spec.imageName field, the value of this
	// spec.cdrom.image.name MUST be a Kubernetes object name.
	Image VirtualMachineImageRef `json:"image"`

	// Connected describes the desired connection state of the CD-ROM device.
	//
	// When true, the CD-ROM device is added and connected to the VM.
	// If the device already exists, it is updated to a connected state.
	//
	// When explicitly set to false, the CD-ROM device is added but remains
	// disconnected from the VM. If the CD-ROM device already exists, it is
	// updated to a disconnected state.
	//
	// Note: Before disconnecting a CD-ROM, the device may need to be unmounted
	// in the guest OS. Refer to the following KB article for more details:
	// https://knowledge.broadcom.com/external/article?legacyId=2144053
	//
	// Defaults to true if omitted.
	Connected *bool `json:"connected,omitempty"`

	// AllowGuestControl describes whether or not a web console connection
	// may be used to connect/disconnect the CD-ROM device.
	//
	// Defaults to true if omitted.
	AllowGuestControl *bool `json:"allowGuestControl,omitempty"`
}

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

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

type VirtualMachineClassHardware struct {
	// +optional
	Cpus int64 `json:"cpus,omitempty"`

	// +optional
	Memory resource.Quantity `json:"memory,omitempty"`

	// +optional
	Devices VirtualDevices `json:"devices,omitempty"`

	// +optional
	InstanceStorage InstanceStorage `json:"instanceStorage,omitempty"`
}

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

type VirtualMachineClassPolicies struct {
	Resources VirtualMachineClassResources `json:"resources,omitempty"`
}

type VirtualMachineClassResources struct {
	// +optional
	Requests VirtualMachineResourceSpec `json:"requests,omitempty"`

	// +optional
	Limits VirtualMachineResourceSpec `json:"limits,omitempty"`
}

type VirtualMachineClassSpec struct {

	// ControllerName describes the name of the controller responsible for
	// reconciling VirtualMachine resources that are realized from this
	// VirtualMachineClass.
	//
	// When omitted, controllers reconciling VirtualMachine resources determine
	// the default controller name from the environment variable
	// DEFAULT_VM_CLASS_CONTROLLER_NAME. If this environment variable is not
	// defined or empty, it defaults to vmoperator.vmware.com/vsphere.
	//
	// Once a non-empty value is assigned to this field, attempts to set this
	// field to an empty value will be silently ignored.
	ControllerName string `json:"controllerName,omitempty"`

	// Hardware describes the configuration of the VirtualMachineClass
	// attributes related to virtual hardware. The configuration specified in
	// this field is used to customize the virtual hardware characteristics of
	// any VirtualMachine associated with this VirtualMachineClass.
	Hardware VirtualMachineClassHardware `json:"hardware,omitempty"`

	// Policies describes the configuration of the VirtualMachineClass
	// attributes related to virtual infrastructure policy. The configuration
	// specified in this field is used to customize various policies related to
	// infrastructure resource consumption.
	Policies VirtualMachineClassPolicies `json:"policies,omitempty"`

	// Description describes the configuration of the VirtualMachineClass which
	// is not related to virtual hardware or infrastructure policy. This field
	// is used to address remaining specs about this VirtualMachineClass.
	Description string `json:"description,omitempty"`

	// ConfigSpec describes additional configuration information for a
	// VirtualMachine.
	// The contents of this field are the VirtualMachineConfigSpec data object
	// (https://bit.ly/3HDtiRu) marshaled to JSON using the discriminator
	// field "_typeName" to preserve type information.
	ConfigSpec json.RawMessage `json:"configSpec,omitempty"`

	// ReservedProfileID describes the reservation profile associated with
	// the namespace-scoped VirtualMachineClass object.
	ReservedProfileID string `json:"reservedProfileID,omitempty"`

	// ReservedSlots describes the number of slots reserved for VMs that use
	// this VirtualMachineClass.
	// This field is only valid in conjunction with reservedProfileID.
	ReservedSlots int32 `json:"reservedSlots,omitempty"`
}

type VirtualMachineClassStatus struct {
}

type VirtualMachineCryptoSpec struct {

	// EncryptionClassName describes the name of the EncryptionClass resource
	// used to encrypt this VM.
	//
	// Please note, this field is not required to encrypt the VM. If the
	// underlying platform has a default key provider, the VM may still be fully
	// or partially encrypted depending on the specified storage and VM classes.
	//
	// If there is a default key provider and an encryption storage class is
	// selected, the files in the VM's home directory and non-PVC virtual disks
	// will be encrypted
	//
	// If there is a default key provider and a VM Class with a virtual, trusted
	// platform module (vTPM) is selected, the files in the VM's home directory,
	// minus any virtual disks, will be encrypted.
	//
	// If the underlying vSphere platform does not have a default key provider,
	// then this field is required when specifying an encryption storage class
	// and/or a VM Class with a vTPM.
	//
	// If this field is set, spec.storageClass must use an encryption-enabled
	// storage class.
	EncryptionClassName string `json:"encryptionClassName,omitempty"`

	// UseDefaultKeyProvider describes the desired behavior for when an explicit
	// EncryptionClass is not provided.
	//
	// When an explicit EncryptionClass is not provided and this value is true:
	//
	// - Deploying a VirtualMachine with an encryption storage policy or vTPM
	//   will be encrypted using the default key provider.
	//
	// - If a VirtualMachine is not encrypted, uses an encryption storage
	//   policy or has a virtual, trusted platform module (vTPM), there is a
	//   default key provider, the VM will be encrypted using the default key
	//   provider.
	//
	// - If a VirtualMachine is encrypted with a provider other than the default
	//   key provider, the VM will be rekeyed using the default key provider.
	//
	// When an explicit EncryptionClass is not provided and this value is false:
	//
	// - Deploying a VirtualMachine with an encryption storage policy or vTPM
	//   will fail.
	//
	// - If a VirtualMachine is encrypted with a provider other than the default
	//   key provider, the VM will be not be rekeyed.
	//
	//   Please note, this could result in a VirtualMachine that cannot be
	//   powered on since it is encrypted using a provider or key that may have
	//   been removed. Without the key, the VM cannot be decrypted and thus
	//   cannot be powered on.
	//
	// Defaults to true if omitted.
	UseDefaultKeyProvider *bool `json:"useDefaultKeyProvider,omitempty"`
}

type VirtualMachineCryptoStatus struct {

	// Encrypted describes the observed state of the VirtualMachine's
	// encryption. There may be two values in this list:
	//
	// - Config -- This refers to all of the files related to a VM except any
	//             virtual disks.
	// - Disks  -- This refers to at least one of the VM's attached disks. To
	//             determine the encryption state of the individual disks,
	//             please refer to status.volumes[].crypto.
	Encrypted []VirtualMachineEncryptionType `json:"encrypted,omitempty"`

	// ProviderID describes the provider ID used to encrypt the VirtualMachine.
	// Please note, this field will be empty if the VirtualMachine is not
	// encrypted.
	ProviderID string `json:"providerID,omitempty"`

	// KeyID describes the key ID used to encrypt the VirtualMachine.
	// Please note, this field will be empty if the VirtualMachine is not
	// encrypted.
	KeyID string `json:"keyID,omitempty"`
}

type VirtualMachineEncryptionType string

type VirtualMachineGuestOSIdentifier string

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

	Spec   VirtualMachineImageSpec   `json:"spec,omitempty"`
	Status VirtualMachineImageStatus `json:"status,omitempty"`
}

type VirtualMachineImageDiskInfo struct {

	// Capacity is the virtual disk capacity in bytes.
	Capacity *resource.Quantity `json:"capacity,omitempty"`

	// Size is the estimated populated size of the virtual disk in bytes.
	Size *resource.Quantity `json:"size,omitempty"`
}

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

type VirtualMachineImageOSInfo struct {

	// ID describes the operating system ID.
	//
	// This value is also added to the image resource's labels as
	// VirtualMachineImageOSIDLabel.
	ID string `json:"id,omitempty"`

	// Type describes the operating system type.
	//
	// This value is also added to the image resource's labels as
	// VirtualMachineImageOSTypeLabel.
	Type string `json:"type,omitempty"`

	// Version describes the operating system version.
	//
	// This value is also added to the image resource's labels as
	// VirtualMachineImageOSVersionLabel.
	Version string `json:"version,omitempty"`
}

type VirtualMachineImageProductInfo struct {

	// Product is a general descriptor for the image.
	Product string `json:"product,omitempty"`

	// Vendor describes the organization/user that produced the image.
	Vendor string `json:"vendor,omitempty"`

	// Version describes the short-form version of the image.
	Version string `json:"version,omitempty"`

	// FullVersion describes the long-form version of the image.
	FullVersion string `json:"fullVersion,omitempty"`
}

type VirtualMachineImageRef struct {
	// Kind describes the type of image, either a namespace-scoped
	// VirtualMachineImage or cluster-scoped ClusterVirtualMachineImage.
	Kind string `json:"kind"`

	// Name refers to the name of a VirtualMachineImage resource in the same
	// namespace as this VM or a cluster-scoped ClusterVirtualMachineImage.
	Name string `json:"name"`
}

type VirtualMachineImageSpec struct {

	// ProviderRef is a reference to the resource that contains the source of
	// this image's information.
	ProviderRef *vmopv1common.LocalObjectRef `json:"providerRef,omitempty"`
}

type VirtualMachineImageStatus struct {

	// Name describes the display name of this image.
	Name string `json:"name,omitempty"`

	// Capabilities describes the image's observed capabilities.
	//
	// The capabilities are discerned when VM Operator reconciles an image.
	// If the source of an image is an OVF in Content Library, then the
	// capabilities are parsed from the OVF property
	// capabilities.image.vmoperator.vmware.com as a comma-separated list of
	// values. Well-known capabilities include:
	//
	// * cloud-init
	// * nvidia-gpu
	// * sriov-net
	//
	// Every capability is also added to the resource's labels as
	// VirtualMachineImageCapabilityLabel + Value. For example, if the
	// capability is "cloud-init" then the following label will be added to the
	// resource: capability.image.vmoperator.vmware.com/cloud-init.
	Capabilities []string `json:"capabilities,omitempty"`

	// Firmware describe the firmware type used by this image, ex. BIOS, EFI.
	Firmware string `json:"firmware,omitempty"`

	// HardwareVersion describes the observed hardware version of this image.
	HardwareVersion *int32 `json:"hardwareVersion,omitempty"`

	// OSInfo describes the observed operating system information for this
	// image.
	//
	// The OS information is also added to the image resource's labels. Please
	// refer to VirtualMachineImageOSInfo for more information.
	OSInfo VirtualMachineImageOSInfo `json:"osInfo,omitempty"`

	// OVFProperties describes the observed user configurable OVF properties defined for this
	// image.
	OVFProperties []OVFProperty `json:"ovfProperties,omitempty"`

	// VMwareSystemProperties describes the observed VMware system properties defined for
	// this image.
	VMwareSystemProperties []vmopv1common.KeyValuePair `json:"vmwareSystemProperties,omitempty"`

	// ProductInfo describes the observed product information for this image.
	ProductInfo VirtualMachineImageProductInfo `json:"productInfo,omitempty"`

	// Disks describes the observed disk information for this image.
	Disks []VirtualMachineImageDiskInfo `json:"disks,omitempty"`

	// ProviderContentVersion describes the content version from the provider item
	// that this image corresponds to. If the provider of this image is a Content
	// Library, this will be the version of the corresponding Content Library item.
	ProviderContentVersion string `json:"providerContentVersion,omitempty"`

	// ProviderItemID describes the ID of the provider item that this image corresponds to.
	// If the provider of this image is a Content Library, this ID will be that of the
	// corresponding Content Library item.
	ProviderItemID string `json:"providerItemID,omitempty"`

	// Conditions describes the observed conditions for this image.
	Conditions []metav1.Condition `json:"conditions,omitempty"`

	// +optional
	//
	// Type describes the content library item type (OVF or ISO) of the image.
	Type string `json:"type,omitempty"`
}

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

type VirtualMachineNetworkConfigDHCPOptionsStatus struct {

	// Enabled describes whether DHCP is enabled.
	Enabled bool `json:"enabled,omitempty"`
}

type VirtualMachineNetworkConfigDHCPStatus struct {

	// IP4 describes the configured state of the IP4 DHCP settings.
	IP4 *VirtualMachineNetworkConfigDHCPOptionsStatus `json:"ip4,omitempty"`

	// IP6 describes the configured state of the IP6 DHCP settings.
	IP6 *VirtualMachineNetworkConfigDHCPOptionsStatus `json:"ip6,omitempty"`
}

type VirtualMachineNetworkConfigDNSStatus struct {

	// HostName is the host name portion of the DNS name. For example,
	// the "my-vm" part of "my-vm.domain.local".
	HostName string `json:"hostName,omitempty"`

	// DomainName is the domain name portion of the DNS name. For example,
	// the "domain.local" part of "my-vm.domain.local".
	DomainName string `json:"domainName,omitempty"`

	// Nameservers is a list of the IP addresses for the DNS servers to use.
	//
	// IP4 addresses are specified using dotted decimal notation. For example,
	// "192.0.2.1".
	//
	// IP6 addresses are 128-bit addresses represented as eight fields of up to
	// four hexadecimal digits. A colon separates each field (:). For example,
	// 2001:DB8:101::230:6eff:fe04:d9ff. The address can also consist of the
	// symbol '::' to represent multiple 16-bit groups of contiguous 0's only
	// once in an address as described in RFC 2373.
	Nameservers []string `json:"nameservers,omitempty"`

	// SearchDomains is a list of domains in which to search for hosts, in the
	// order of preference.
	SearchDomains []string `json:"searchDomains,omitempty"`
}

type VirtualMachineNetworkConfigInterfaceIPStatus struct {

	// DHCP describes the interface's configured DHCP options.
	DHCP *VirtualMachineNetworkConfigDHCPStatus `json:"dhcp,omitempty"`

	// Addresses describes configured IP addresses for this interface.
	// Addresses include the network's prefix length, ex. 192.168.0.0/24 or
	// 2001:DB8:101::230:6eff:fe04:d9ff::/64.
	Addresses []string `json:"addresses,omitempty"`

	// Gateway4 describes the interface's configured, default, IP4 gateway.
	//
	// Please note the IP address include the network prefix length, ex.
	// 192.168.0.1/24.
	Gateway4 string `json:"gateway4,omitempty"`

	// Gateway6 describes the interface's configured, default, IP6 gateway.
	//
	// Please note the IP address includes the network prefix length, ex.
	// 2001:db8:101::1/64.
	Gateway6 string `json:"gateway6,omitempty"`
}

type VirtualMachineNetworkConfigInterfaceStatus struct {

	// Name describes the corresponding network interface with the same name
	// in the VM's desired network interface list.
	//
	// Please note this name is not necessarily related to the name of the
	// device as it is surfaced inside of the guest.
	Name string `json:"name,omitempty"`

	// IP describes the interface's configured IP information.
	IP *VirtualMachineNetworkConfigInterfaceIPStatus `json:"ip,omitempty"`

	// DNS describes the interface's configured DNS information.
	DNS *VirtualMachineNetworkConfigDNSStatus `json:"dns,omitempty"`
}

type VirtualMachineNetworkConfigStatus struct {

	// Interfaces describes the configured state of the network interfaces.
	Interfaces []VirtualMachineNetworkConfigInterfaceStatus `json:"interfaces,omitempty"`

	// DNS describes the configured state of client-side DNS.
	DNS *VirtualMachineNetworkConfigDNSStatus `json:"dns,omitempty"`
}

type VirtualMachineNetworkDHCPOptionsStatus struct {

	// Config describes platform-dependent settings for the DHCP client.
	//
	// The key part is a unique number while the value part is the platform
	// specific configuration command. For example on Linux and BSD systems
	// using the file dhclient.conf output would be reported at system scope:
	// key='1', value='timeout 60;' key='2', value='reboot 10;'. The output
	// reported per interface would be:
	// key='1', value='prepend domain-name-servers 192.0.2.1;'
	// key='2', value='require subnet-mask, domain-name-servers;'.
	Config []vmopv1common.KeyValuePair `json:"config,omitempty"`

	// Enabled reports the status of the DHCP client services.
	Enabled bool `json:"enabled,omitempty"`
}

type VirtualMachineNetworkDHCPStatus struct {

	// IP4 describes the observed state of the IP4 DHCP client settings.
	IP4 VirtualMachineNetworkDHCPOptionsStatus `json:"ip4,omitempty"`

	// IP6 describes the observed state of the IP6 DHCP client settings.
	IP6 VirtualMachineNetworkDHCPOptionsStatus `json:"ip6,omitempty"`
}

type VirtualMachineNetworkDNSStatus struct {

	// DHCP indicates whether or not dynamic host control protocol (DHCP) was
	// used to configure DNS configuration.
	DHCP bool `json:"dhcp,omitempty"`

	// HostName is the host name portion of the DNS name. For example,
	// the "my-vm" part of "my-vm.domain.local".
	HostName string `json:"hostName,omitempty"`

	// DomainName is the domain name portion of the DNS name. For example,
	// the "domain.local" part of "my-vm.domain.local".
	DomainName string `json:"domainName,omitempty"`

	// Nameservers is a list of the IP addresses for the DNS servers to use.
	//
	// IP4 addresses are specified using dotted decimal notation. For example,
	// "192.0.2.1".
	//
	// IP6 addresses are 128-bit addresses represented as eight fields of up to
	// four hexadecimal digits. A colon separates each field (:). For example,
	// 2001:DB8:101::230:6eff:fe04:d9ff. The address can also consist of the
	// symbol '::' to represent multiple 16-bit groups of contiguous 0's only
	// once in an address as described in RFC 2373.
	Nameservers []string `json:"nameservers,omitempty"`

	// SearchDomains is a list of domains in which to search for hosts, in the
	// order of preference.
	SearchDomains []string `json:"searchDomains,omitempty"`
}

type VirtualMachineNetworkIPRouteGatewayStatus struct {

	// Device is the name of the device in the guest for which this gateway
	// applies.
	Device string `json:"device,omitempty"`

	// Address is the IP4 or IP6 address of the gateway.
	Address string `json:"address,omitempty"`
}

type VirtualMachineNetworkIPRouteStatus struct {

	// Gateway describes where to send the packets to next.
	Gateway VirtualMachineNetworkIPRouteGatewayStatus `json:"gateway,omitempty"`

	// NetworkAddress is the IP4 or IP6 address of the destination network.
	//
	// Addresses include the network's prefix length, ex. 192.168.0.0/24 or
	// 2001:DB8:101::230:6eff:fe04:d9ff::/64.
	//
	// IP6 addresses are 128-bit addresses represented as eight fields of up to
	// four hexadecimal digits. A colon separates each field (:). For example,
	// 2001:DB8:101::230:6eff:fe04:d9ff. The address can also consist of symbol
	// '::' to represent multiple 16-bit groups of contiguous 0's only once in
	// an address as described in RFC 2373.
	NetworkAddress string `json:"networkAddress,omitempty"`
}

type VirtualMachineNetworkIPStackStatus struct {

	// DHCP describes the VM's observed, client-side, system-wide DHCP options.
	DHCP *VirtualMachineNetworkDHCPStatus `json:"dhcp,omitempty"`

	// DNS describes the VM's observed, client-side DNS configuration.
	DNS *VirtualMachineNetworkDNSStatus `json:"dns,omitempty"`

	// IPRoutes contain the VM's routing tables for all address families.
	IPRoutes []VirtualMachineNetworkIPRouteStatus `json:"ipRoutes,omitempty"`

	// KernelConfig describes the observed state of the VM's kernel IP
	// configuration settings.
	//
	// The key part contains a unique number while the value part contains the
	// 'key=value' as provided by the underlying provider. For example, on
	// Linux and/or BSD, the systcl -a output would be reported as:
	// key='5', value='net.ipv4.tcp_keepalive_time = 7200'.
	KernelConfig []vmopv1common.KeyValuePair `json:"kernelConfig,omitempty"`
}

type VirtualMachineNetworkInterfaceIPAddrStatus struct {

	// Address is an IP4 or IP6 address and their network prefix length.
	//
	// An IP4 address is specified using dotted decimal notation. For example,
	// "192.0.2.1".
	//
	// IP6 addresses are 128-bit addresses represented as eight fields of up to
	// four hexadecimal digits. A colon separates each field (:). For example,
	// 2001:DB8:101::230:6eff:fe04:d9ff. The address can also consist of the
	// symbol '::' to represent multiple 16-bit groups of contiguous 0's only
	// once in an address as described in RFC 2373.
	Address string `json:"address,omitempty"`

	// Lifetime describes when this address will expire.
	Lifetime metav1.Time `json:"lifetime,omitempty"`

	// Origin describes how this address was configured.
	Origin string `json:"origin,omitempty"`

	// State describes the state of this IP address.
	State string `json:"state,omitempty"`
}

type VirtualMachineNetworkInterfaceIPStatus struct {

	// AutoConfigurationEnabled describes whether or not ICMPv6 router
	// solicitation requests are enabled or disabled from a given interface.
	//
	// These requests acquire an IP6 address and default gateway route from
	// zero-to-many routers on the connected network.
	//
	// If not set then ICMPv6 is not available on this VM.
	AutoConfigurationEnabled *bool `json:"autoConfigurationEnabled,omitempty"`

	// DHCP describes the VM's observed, client-side, interface-specific DHCP
	// options.
	DHCP *VirtualMachineNetworkDHCPStatus `json:"dhcp,omitempty"`

	// Addresses describes observed IP addresses for this interface.
	Addresses []VirtualMachineNetworkInterfaceIPAddrStatus `json:"addresses,omitempty"`

	// MACAddr describes the observed MAC address for this interface.
	MACAddr string `json:"macAddr,omitempty"`
}

type VirtualMachineNetworkInterfaceSpec struct {

	// Name describes the unique name of this network interface, used to
	// distinguish it from other network interfaces attached to this VM.
	//
	// When the bootstrap provider is Cloud-Init and GuestDeviceName is not
	// specified, the device inside the guest will be renamed to this value.
	// Please note it is up to the user to ensure the provided name does not
	// conflict with any other devices inside the guest, ex. dvd, cdrom, sda, etc.
	Name string `json:"name"`

	// Network is the name of the network resource to which this interface is
	// connected.
	//
	// If no network is provided, then this interface will be connected to the
	// Namespace's default network.
	Network *vmopv1common.PartialObjectRef `json:"network,omitempty"`

	// GuestDeviceName is used to rename the device inside the guest when the
	// bootstrap provider is Cloud-Init. Please note it is up to the user to
	// ensure the provided device name does not conflict with any other devices
	// inside the guest, ex. dvd, cdrom, sda, etc.
	GuestDeviceName string `json:"guestDeviceName,omitempty"`

	// Addresses is an optional list of IP4 or IP6 addresses to assign to this
	// interface.
	//
	// Please note this field is only supported if the connected network
	// supports manual IP allocation.
	//
	// Please note IP4 and IP6 addresses must include the network prefix length,
	// ex. 192.168.0.10/24 or 2001:db8:101::a/64.
	//
	// Please note this field may not contain IP4 addresses if DHCP4 is set
	// to true or IP6 addresses if DHCP6 is set to true.
	//
	// Please note if the Interfaces field is non-empty then this field is
	// ignored and should be specified on the elements in the Interfaces list.
	Addresses []string `json:"addresses,omitempty"`

	// DHCP4 indicates whether or not this interface uses DHCP for IP4
	// networking.
	//
	// Please note this field is only supported if the network connection
	// supports DHCP.
	//
	// Please note this field is mutually exclusive with IP4 addresses in the
	// Addresses field and the Gateway4 field.
	DHCP4 bool `json:"dhcp4,omitempty"`

	// DHCP6 indicates whether or not this interface uses DHCP for IP6
	// networking.
	//
	// Please note this field is only supported if the network connection
	// supports DHCP.
	//
	// Please note this field is mutually exclusive with IP6 addresses in the
	// Addresses field and the Gateway6 field.
	DHCP6 bool `json:"dhcp6,omitempty"`

	// Gateway4 is the default, IP4 gateway for this interface.
	//
	// Please note this field is only supported if the network connection
	// supports manual IP allocation.
	//
	// If the network connection supports manual IP allocation and the
	// Addresses field includes at least one IP4 address, then this field
	// is required.
	//
	// Please note the IP address must include the network prefix length, ex.
	// 192.168.0.1/24.
	//
	// Please note this field is mutually exclusive with DHCP4.
	Gateway4 string `json:"gateway4,omitempty"`

	// Gateway6 is the primary IP6 gateway for this interface.
	//
	// Please note this field is only supported if the network connection
	// supports manual IP allocation.
	//
	// If the network connection supports manual IP allocation and the
	// Addresses field includes at least one IP6 address, then this field
	// is required.
	//
	// Please note the IP address must include the network prefix length, ex.
	// 2001:db8:101::1/64.
	//
	// Please note this field is mutually exclusive with DHCP6.
	Gateway6 string `json:"gateway6,omitempty"`

	// MTU is the Maximum Transmission Unit size in bytes.
	//
	// Please note this feature is available only with the following bootstrap
	// providers: CloudInit.
	MTU *int64 `json:"mtu,omitempty"`

	// Nameservers is a list of IP4 and/or IP6 addresses used as DNS
	// nameservers.
	//
	// Please note this feature is available only with the following bootstrap
	// providers: CloudInit and Sysprep.
	//
	// When using CloudInit and UseGlobalNameserversAsDefault is either unset or
	// true, if nameservers is not provided, the global nameservers will be used
	// instead.
	//
	// Please note that Linux allows only three nameservers
	// (https://linux.die.net/man/5/resolv.conf).
	Nameservers []string `json:"nameservers,omitempty"`

	// Routes is a list of optional, static routes.
	//
	// Please note this feature is available only with the following bootstrap
	// providers: CloudInit.
	Routes []VirtualMachineNetworkRouteSpec `json:"routes,omitempty"`

	// SearchDomains is a list of search domains used when resolving IP
	// addresses with DNS.
	//
	// Please note this feature is available only with the following bootstrap
	// providers: CloudInit.
	//
	// When using CloudInit and UseGlobalSearchDomainsAsDefault is either unset
	// or true, if search domains is not provided, the global search domains
	// will be used instead.
	SearchDomains []string `json:"searchDomains,omitempty"`
}

type VirtualMachineNetworkInterfaceStatus struct {

	// Name describes the corresponding network interface with the same name
	// in the VM's desired network interface list. If unset, then there is no
	// corresponding entry for this interface.
	//
	// Please note this name is not necessarily related to the name of the
	// device as it is surfaced inside of the guest.
	Name string `json:"name,omitempty"`

	// DeviceKey describes the unique hardware device key of this network
	// interface.
	DeviceKey int32 `json:"deviceKey,omitempty"`

	// IP describes the observed state of the interface's IP configuration.
	IP *VirtualMachineNetworkInterfaceIPStatus `json:"ip,omitempty"`

	// DNS describes the observed state of the interface's DNS configuration.
	DNS *VirtualMachineNetworkDNSStatus `json:"dns,omitempty"`
}

type VirtualMachineNetworkRouteSpec struct {
	// To is an IP4 or IP6 address.
	To string `json:"to"`

	// Via is an IP4 or IP6 address.
	Via string `json:"via"`

	// Metric is the weight/priority of the route.
	Metric int32 `json:"metric"`
}

type VirtualMachineNetworkRouteStatus struct {

	// IPRoutes contain the VM's routing tables for all address families.
	IPRoutes []VirtualMachineNetworkIPRouteStatus `json:"ipRoutes,omitempty"`
}

type VirtualMachineNetworkSpec struct {

	// HostName describes the value the guest uses as its host name. If omitted,
	// the name of the VM will be used.
	//
	// Please note, this feature is available with the following bootstrap
	// providers: CloudInit, LinuxPrep, and Sysprep.
	//
	// This field must adhere to the format specified in RFC-1034, Section 3.5
	// for DNS labels:
	//
	//   * The total length is restricted to 63 characters or less.
	//   * The total length is restricted to 15 characters or less on Windows
	//     systems.
	//   * The value may begin with a digit per RFC-1123.
	//   * Underscores are not allowed.
	//   * Dashes are permitted, but not at the start or end of the value.
	//   * Symbol unicode points, such as emoji, are permitted, ex. ✓. However,
	//     please notes that the use of emoji, even where allowed, may not
	//     compatible with the guest operating system, so it recommended to
	//     stick with more common characters for this value.
	//   * The value may be a valid IP4 or IP6 address. Please note, the use of
	//     an IP address for a host name is not compatible with all guest
	//     operating systems and is discouraged. Additionally, using an IP
	//     address for the host name is disallowed if spec.network.domainName is
	//     non-empty.
	//
	// Please note, the combined values of spec.network.hostName and
	// spec.network.domainName may not exceed 255 characters in length.
	HostName string `json:"hostName,omitempty"`

	// DomainName describes the value the guest uses as its domain name.
	//
	// Please note, this feature is available with the following bootstrap
	// providers: CloudInit, LinuxPrep, and Sysprep.
	//
	// This field must adhere to the format specified in RFC-1034, Section 3.5
	// for DNS names:
	//
	//   * When joined with the host name, the total length is restricted to 255
	//     characters or less.
	//   * Individual segments must be 63 characters or less.
	//   * The top-level domain( ex. ".com"), is at least two letters with no
	//     special characters.
	//   * Underscores are not allowed.
	//   * Dashes are permitted, but not at the start or end of the value.
	//   * Long, top-level domain names (ex. ".london") are permitted.
	//   * Symbol unicode points, such as emoji, are disallowed in the top-level
	//     domain.
	//
	// Please note, the combined values of spec.network.hostName and
	// spec.network.domainName may not exceed 255 characters in length.
	//
	// When deploying a guest running Microsoft Windows, this field describes
	// the domain the computer should join.
	DomainName string `json:"domainName,omitempty"`

	// Disabled is a flag that indicates whether or not to disable networking
	// for this VM.
	//
	// When set to true, the VM is not configured with a default interface nor
	// any specified from the Interfaces field.
	Disabled bool `json:"disabled,omitempty"`

	// Nameservers is a list of IP4 and/or IP6 addresses used as DNS
	// nameservers. These are applied globally.
	//
	// Please note global nameservers are only available with the following
	// bootstrap providers: LinuxPrep and Sysprep. The Cloud-Init bootstrap
	// provider supports per-interface nameservers. However, when Cloud-Init
	// is used and UseGlobalNameserversAsDefault is true, the global
	// nameservers will be used when the per-interface nameservers is not
	// provided.
	//
	// Please note that Linux allows only three nameservers
	// (https://linux.die.net/man/5/resolv.conf).
	Nameservers []string `json:"nameservers,omitempty"`

	// SearchDomains is a list of search domains used when resolving IP
	// addresses with DNS. These are applied globally.
	//
	// Please note global search domains are only available with the following
	// bootstrap providers: LinuxPrep and Sysprep. The Cloud-Init bootstrap
	// provider supports per-interface search domains. However, when Cloud-Init
	// is used and UseGlobalSearchDomainsAsDefault is true, the global search
	// domains will be used when the per-interface search domains is not provided.
	SearchDomains []string `json:"searchDomains,omitempty"`

	// Interfaces is the list of network interfaces used by this VM.
	//
	// If the Interfaces field is empty and the Disabled field is false, then
	// a default interface with the name eth0 will be created.
	//
	// The maximum number of network interface allowed is 10 because a vSphere
	// virtual machine may not have more than 10 virtual ethernet card devices.
	Interfaces []VirtualMachineNetworkInterfaceSpec `json:"interfaces,omitempty"`
}

type VirtualMachineNetworkStatus struct {

	// Config describes the resolved, configured network settings for the VM,
	// such as an interface's IP address obtained from IPAM, or global DNS
	// settings.
	//
	// Please note this information does *not* represent the *observed* network
	// state of the VM, but is intended for situations where someone boots a VM
	// with no appropriate bootstrap engine and needs to know the network config
	// valid for the deployed VM.
	Config *VirtualMachineNetworkConfigStatus `json:"config,omitempty"`

	// Interfaces describes the status of the VM's network interfaces.
	Interfaces []VirtualMachineNetworkInterfaceStatus `json:"interfaces,omitempty"`

	// IPStacks describes information about the guest's configured IP networking
	// stacks.
	IPStacks []VirtualMachineNetworkIPStackStatus `json:"ipStacks,omitempty"`

	// PrimaryIP4 describes the VM's primary IP4 address.
	//
	// If the bootstrap provider is CloudInit then this value is set to the
	// value of the VM's "guestinfo.local-ipv4" property. Please see
	// https://bit.ly/3NJB534 for more information on how this value is
	// calculated.
	//
	// If the bootstrap provider is anything else then this field is set to the
	// value of the infrastructure VM's "guest.ipAddress" field. Please see
	// https://bit.ly/3Au0jM4 for more information.
	PrimaryIP4 string `json:"primaryIP4,omitempty"`

	// PrimaryIP6 describes the VM's primary IP6 address.
	//
	// If the bootstrap provider is CloudInit then this value is set to the
	// value of the VM's "guestinfo.local-ipv6" property. Please see
	// https://bit.ly/3NJB534 for more information on how this value is
	// calculated.
	//
	// If the bootstrap provider is anything else then this field is set to the
	// value of the infrastructure VM's "guest.ipAddress" field. Please see
	// https://bit.ly/3Au0jM4 for more information.
	PrimaryIP6 string `json:"primaryIP6,omitempty"`
}

type VirtualMachinePowerOpMode string

type VirtualMachinePowerState string

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

	Spec   VirtualMachinePublishRequestSpec   `json:"spec,omitempty"`
	Status VirtualMachinePublishRequestStatus `json:"status,omitempty"`
}

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

type VirtualMachinePublishRequestSource struct {

	// Name is the name of the referenced object.
	//
	// If omitted this value defaults to the name of the
	// VirtualMachinePublishRequest resource.
	Name string `json:"name,omitempty"`

	// APIVersion is the API version of the referenced object.
	APIVersion string `json:"apiVersion,omitempty"`

	// Kind is the kind of referenced object.
	Kind string `json:"kind,omitempty"`
}

type VirtualMachinePublishRequestSpec struct {

	// Source is the source of the publication request, ex. a VirtualMachine
	// resource.
	//
	// If this value is omitted then the publication controller checks to
	// see if there is a resource with the same name as this
	// VirtualMachinePublishRequest resource, an API version equal to
	// spec.source.apiVersion, and a kind equal to spec.source.kind. If such
	// a resource exists, then it is the source of the publication.
	Source VirtualMachinePublishRequestSource `json:"source,omitempty"`

	// Target is the target of the publication request, ex. item
	// information and a ContentLibrary resource.
	//
	// If this value is omitted, the controller uses spec.source.name + "-image"
	// as the name of the published item. Additionally, when omitted the
	// controller attempts to identify the target location by matching a
	// resource with an API version equal to spec.target.location.apiVersion, a
	// kind equal to spec.target.location.kind, w/ the label
	// "imageregistry.vmware.com/default".
	//
	// Please note that while optional, if a VirtualMachinePublishRequest sans
	// target information is applied to a namespace without a default
	// publication target, then the VirtualMachinePublishRequest resource
	// will be marked in error.
	Target VirtualMachinePublishRequestTarget `json:"target,omitempty"`

	// TTLSecondsAfterFinished is the time-to-live duration for how long this
	// resource will be allowed to exist once the publication operation
	// completes. After the TTL expires, the resource will be automatically
	// deleted without the user having to take any direct action.
	//
	// If this field is unset then the request resource will not be
	// automatically deleted. If this field is set to zero then the request
	// resource is eligible for deletion immediately after it finishes.
	TTLSecondsAfterFinished *int64 `json:"ttlSecondsAfterFinished,omitempty"`
}

type VirtualMachinePublishRequestStatus struct {

	// SourceRef is the reference to the source of the publication request,
	// ex. a VirtualMachine resource.
	SourceRef *VirtualMachinePublishRequestSource `json:"sourceRef,omitempty"`

	// TargetRef is the reference to the target of the publication request,
	// ex. item information and a ContentLibrary resource.
	TargetRef *VirtualMachinePublishRequestTarget `json:"targetRef,omitempty"`

	// CompletionTime represents time when the request was completed. It is not
	// guaranteed to be set in happens-before order across separate operations.
	// It is represented in RFC3339 form and is in UTC.
	//
	// The value of this field should be equal to the value of the
	// LastTransitionTime for the status condition Type=Complete.
	CompletionTime metav1.Time `json:"completionTime,omitempty"`

	// StartTime represents time when the request was acknowledged by the
	// controller. It is not guaranteed to be set in happens-before order
	// across separate operations. It is represented in RFC3339 form and is
	// in UTC.
	StartTime metav1.Time `json:"startTime,omitempty"`

	// Attempts represents the number of times the request to publish the VM
	// has been attempted.
	Attempts int64 `json:"attempts,omitempty"`

	// LastAttemptTime represents the time when the latest request was sent.
	LastAttemptTime metav1.Time `json:"lastAttemptTime,omitempty"`

	// ImageName is the name of the VirtualMachineImage resource that is
	// eventually realized in the same namespace as the VM and publication
	// request after the publication operation completes.
	//
	// This field will not be set until the VirtualMachineImage resource
	// is realized.
	ImageName string `json:"imageName,omitempty"`

	// Ready is set to true only when the VM has been published successfully
	// and the new VirtualMachineImage resource is ready.
	//
	// Readiness is determined by waiting until there is status condition
	// Type=Complete and ensuring it and all other status conditions present
	// have a Status=True. The conditions present will be:
	//
	//   * SourceValid
	//   * TargetValid
	//   * Uploaded
	//   * ImageAvailable
	//   * Complete
	Ready bool `json:"ready,omitempty"`

	// Conditions is a list of the latest, available observations of the
	// request's current state.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type VirtualMachinePublishRequestTarget struct {

	// Item contains information about the name of the object to which
	// the VM is published.
	//
	// Please note this value is optional and if omitted, the controller
	// will use spec.source.name + "-image" as the name of the published
	// item.
	Item VirtualMachinePublishRequestTargetItem `json:"item,omitempty"`

	// Location contains information about the location to which to publish
	// the VM.
	Location VirtualMachinePublishRequestTargetLocation `json:"location,omitempty"`
}

type VirtualMachinePublishRequestTargetItem struct {

	// Name is the name of the published object.
	//
	// If the spec.target.location.apiVersion equals
	// imageregistry.vmware.com/v1alpha1 and the spec.target.location.kind
	// equals ContentLibrary, then this should be the name that will
	// show up in vCenter Content Library, not the custom resource name
	// in the namespace.
	//
	// If omitted then the controller will use spec.source.name + "-image".
	Name string `json:"name,omitempty"`

	// Description is the description to assign to the published object.
	Description string `json:"description,omitempty"`
}

type VirtualMachinePublishRequestTargetLocation struct {

	// Name is the name of the referenced object.
	//
	// Please note an error will be returned if this field is not
	// set in a namespace that lacks a default publication target.
	//
	// A default publication target is a resource with an API version
	// equal to spec.target.location.apiVersion, a kind equal to
	// spec.target.location.kind, and has the label
	// "imageregistry.vmware.com/default".
	Name string `json:"name,omitempty"`

	// APIVersion is the API version of the referenced object.
	APIVersion string `json:"apiVersion,omitempty"`

	// Kind is the kind of referenced object.
	Kind string `json:"kind,omitempty"`
}

type VirtualMachineReadinessProbeSpec struct {

	// TCPSocket specifies an action involving a TCP port.
	//
	// Deprecated: The TCPSocket action requires network connectivity that is not supported in all environments.
	// This field will be removed in a later API version.
	TCPSocket *TCPSocketAction `json:"tcpSocket,omitempty"`

	// GuestHeartbeat specifies an action involving the guest heartbeat status.
	GuestHeartbeat *GuestHeartbeatAction `json:"guestHeartbeat,omitempty"`

	// GuestInfo specifies an action involving key/value pairs from GuestInfo.
	//
	// The elements are evaluated with the logical AND operator, meaning
	// all expressions must evaluate as true for the probe to succeed.
	//
	// For example, a VM resource's probe definition could be specified as the
	// following:
	//
	//         guestInfo:
	//         - key:   ready
	//           value: true
	//
	// With the above configuration in place, the VM would not be considered
	// ready until the GuestInfo key "ready" was set to the value "true".
	//
	// From within the guest operating system it is possible to set GuestInfo
	// key/value pairs using the program "vmware-rpctool," which is included
	// with VM Tools. For example, the following command will set the key
	// "guestinfo.ready" to the value "true":
	//
	//         vmware-rpctool "info-set guestinfo.ready true"
	//
	// Once executed, the VM's readiness probe will be signaled and the
	// VM resource will be marked as ready.
	GuestInfo []GuestInfoAction `json:"guestInfo,omitempty"`

	// TimeoutSeconds specifies a number of seconds after which the probe times out.
	// Defaults to 10 seconds. Minimum value is 1.
	TimeoutSeconds int32 `json:"timeoutSeconds,omitempty"`

	// PeriodSeconds specifics how often (in seconds) to perform the probe.
	// Defaults to 10 seconds. Minimum value is 1.
	PeriodSeconds int32 `json:"periodSeconds,omitempty"`
}

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

	Spec   VirtualMachineReplicaSetSpec   `json:"spec,omitempty"`
	Status VirtualMachineReplicaSetStatus `json:"status,omitempty"`
}

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

type VirtualMachineReplicaSetSpec struct {
	// +optional
	// +kubebuilder:default=1
	//
	// Replicas is the number of desired replicas.
	// This is a pointer to distinguish between explicit zero and unspecified.
	// Defaults to 1.
	Replicas *int32 `json:"replicas,omitempty"`

	// +optional
	// +kubebuilder:validation:Enum=Random
	//
	// DeletePolicy defines the policy used to identify nodes to delete when downscaling.
	// Only supported deletion policy is "Random".
	DeletePolicy string `json:"deletePolicy,omitempty"`

	// +optional
	//
	// Selector is a label to query over virtual machines that should match the
	// replica count. A virtual machine's label keys and values must match in order
	// to be controlled by this VirtualMachineReplicaSet.
	//
	// It must match the VirtualMachine template's labels.
	// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors
	Selector *metav1.LabelSelector `json:"selector"`

	// +optional
	//
	// Template is the object that describes the virtual machine that will be
	// created if insufficient replicas are detected.
	Template VirtualMachineTemplateSpec `json:"template,omitempty"`
}

type VirtualMachineReplicaSetStatus struct {
	// +optional
	//
	// Replicas is the most recently observed number of replicas.
	Replicas int32 `json:"replicas"`

	// +optional
	//
	// FullyLabeledReplicas is the number of replicas that have labels matching the
	// labels of the virtual machine template of the VirtualMachineReplicaSet.
	FullyLabeledReplicas int32 `json:"fullyLabeledReplicas,omitempty"`

	// +optional
	//
	// ReadyReplicas is the number of ready replicas for this VirtualMachineReplicaSet. A
	// virtual machine is considered ready when it's "Ready" condition is marked as
	// true.
	ReadyReplicas int32 `json:"readyReplicas,omitempty"`

	// +optional
	//
	// ObservedGeneration reflects the generation of the most recently observed
	// VirtualMachineReplicaSet.
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// +optional
	//
	// Conditions represents the latest available observations of a
	// VirtualMachineReplicaSet's current state.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type VirtualMachineReservedSpec struct {
	ResourcePolicyName string `json:"resourcePolicyName,omitempty"`
}

type VirtualMachineResourceSpec struct {
	// +optional
	Cpu resource.Quantity `json:"cpu,omitempty"` //nolint:stylecheck,revive

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

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

	Spec   VirtualMachineServiceSpec   `json:"spec,omitempty"`
	Status VirtualMachineServiceStatus `json:"status,omitempty"`
}

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

type VirtualMachineServicePort struct {
	// Name describes the name to be used to identify this
	// VirtualMachineServicePort.
	Name string `json:"name"`

	// Protocol describes the Layer 4 transport protocol for this port.
	// Supports "TCP", "UDP", and "SCTP".
	Protocol string `json:"protocol"`

	// Port describes the external port that will be exposed by the service.
	Port int32 `json:"port"`

	// TargetPort describes the internal port open on a VirtualMachine that
	// should be mapped to the external Port.
	TargetPort int32 `json:"targetPort"`
}

type VirtualMachineServiceSpec struct {
	// Type specifies a desired VirtualMachineServiceType for this
	// VirtualMachineService. Supported types are ClusterIP, LoadBalancer,
	// ExternalName.
	Type VirtualMachineServiceType `json:"type"`

	// Ports specifies a list of VirtualMachineServicePort to expose with this
	// VirtualMachineService. Each of these ports will be an accessible network
	// entry point to access this service by.
	Ports []VirtualMachineServicePort `json:"ports,omitempty"`

	// Selector specifies a map of key-value pairs, also known as a Label
	// Selector, that is used to match this VirtualMachineService with the set
	// of VirtualMachines that should back this VirtualMachineService.
	Selector map[string]string `json:"selector,omitempty"`

	// LoadBalancer will get created with the IP specified in this field.
	// Only applies to VirtualMachineService Type: LoadBalancer
	// This feature depends on whether the underlying load balancer provider
	// supports specifying the loadBalancerIP when a load balancer is created.
	// This field will be ignored if the provider does not support the feature.
	// Deprecated: This field was under-specified and its meaning varies across implementations.
	// Using it is non-portable and it may not support dual-stack.
	// Users are encouraged to use implementation-specific annotations when available.
	LoadBalancerIP string `json:"loadBalancerIP,omitempty"`

	// LoadBalancerSourceRanges is an array of IP addresses in the format of
	// CIDRs, for example: 103.21.244.0/22 and 10.0.0.0/24.
	// If specified and supported by the load balancer provider, this will
	// restrict ingress traffic to the specified client IPs. This field will be
	// ignored if the provider does not support the feature.
	LoadBalancerSourceRanges []string `json:"loadBalancerSourceRanges,omitempty"`

	// ClusterIP is the IP address of the service and is usually assigned
	// randomly by the master. If an address is specified manually and is not in
	// use by others, it will be allocated to the service; otherwise, creation
	// of the service will fail. This field can not be changed through updates.
	// Valid values are "None", empty string (""), or a valid IP address. "None"
	// can be specified for headless services when proxying is not required.
	// Only applies to types ClusterIP and LoadBalancer.
	// Ignored if type is ExternalName.
	// More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies
	ClusterIP string `json:"clusterIp,omitempty"`

	// ExternalName is the external reference that kubedns or equivalent will
	// return as a CNAME record for this service. No proxying will be involved.
	// Must be a valid RFC-1123 hostname (https://tools.ietf.org/html/rfc1123)
	// and requires Type to be ExternalName.
	ExternalName string `json:"externalName,omitempty"`
}

type VirtualMachineServiceStatus struct {

	// LoadBalancer contains the current status of the load balancer,
	// if one is present.
	LoadBalancer LoadBalancerStatus `json:"loadBalancer,omitempty"`
}

type VirtualMachineServiceType string

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

	Spec   VirtualMachineSetResourcePolicySpec   `json:"spec,omitempty"`
	Status VirtualMachineSetResourcePolicyStatus `json:"status,omitempty"`
}

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

type VirtualMachineSetResourcePolicySpec struct {
	ResourcePool        ResourcePoolSpec `json:"resourcePool,omitempty"`
	Folder              string           `json:"folder,omitempty"`
	ClusterModuleGroups []string         `json:"clusterModuleGroups,omitempty"`
}

type VirtualMachineSetResourcePolicyStatus struct {
	ClusterModules []VSphereClusterModuleStatus `json:"clustermodules,omitempty"`
}

type VirtualMachineSpec struct {

	// Cdrom describes the desired state of the VM's CD-ROM devices.
	//
	// Each CD-ROM device requires a reference to an ISO-type
	// VirtualMachineImage or ClusterVirtualMachineImage resource as backing.
	//
	// Multiple CD-ROM devices using the same backing image, regardless of image
	// kinds (namespace or cluster scope), are not allowed.
	//
	// CD-ROM devices can be added, updated, or removed when the VM is powered
	// off. When the VM is powered on, only the connection state of existing
	// CD-ROM devices can be changed.
	// CD-ROM devices are attached to the VM in the specified list-order.
	Cdrom []VirtualMachineCdromSpec `json:"cdrom,omitempty"`

	// Image describes the reference to the VirtualMachineImage or
	// ClusterVirtualMachineImage resource used to deploy this VM.
	//
	// Please note, unlike the field spec.imageName, the value of
	// spec.image.name MUST be a Kubernetes object name.
	//
	// Please also note, when creating a new VirtualMachine, if this field and
	// spec.imageName are both non-empty, then they must refer to the same
	// resource or an error is returned.
	//
	// Please note, this field *may* be empty if the VM was imported instead of
	// deployed by VM Operator. An imported VirtualMachine resource references
	// an existing VM on the underlying platform that was not deployed from a
	// VM image.
	Image *VirtualMachineImageRef `json:"image,omitempty"`

	// ImageName describes the name of the image resource used to deploy this
	// VM.
	//
	// This field may be used to specify the name of a VirtualMachineImage
	// or ClusterVirtualMachineImage resource. The resolver first checks to see
	// if there is a VirtualMachineImage with the specified name in the
	// same namespace as the VM being deployed. If no such resource exists, the
	// resolver then checks to see if there is a ClusterVirtualMachineImage
	// resource with the specified name.
	//
	// This field may also be used to specify the display name (vSphere name) of
	// a VirtualMachineImage or ClusterVirtualMachineImage resource. If the
	// display name unambiguously resolves to a distinct VM image (among all
	// existing VirtualMachineImages in the VM's namespace and all existing
	// ClusterVirtualMachineImages), then a mutation webhook updates the
	// spec.image field with the reference to the resolved VM image. If the
	// display name resolves to multiple or no VM images, then the mutation
	// webhook denies the request and returns an error.
	//
	// Please also note, when creating a new VirtualMachine, if this field and
	// spec.image are both non-empty, then they must refer to the same
	// resource or an error is returned.
	//
	// Please note, this field *may* be empty if the VM was imported instead of
	// deployed by VM Operator. An imported VirtualMachine resource references
	// an existing VM on the underlying platform that was not deployed from a
	// VM image.
	ImageName string `json:"imageName,omitempty"`

	// ClassName describes the name of the VirtualMachineClass resource used to
	// deploy this VM.
	//
	// Please note, this field *may* be empty if the VM was imported instead of
	// deployed by VM Operator. An imported VirtualMachine resource references
	// an existing VM on the underlying platform that was not deployed from a
	// VM class.
	ClassName string `json:"className,omitempty"`

	// Crypto describes the desired encryption state of the VirtualMachine.
	Crypto *VirtualMachineCryptoSpec `json:"crypto,omitempty"`

	// StorageClass describes the name of a Kubernetes StorageClass resource
	// used to configure this VM's storage-related attributes.
	//
	// Please see https://kubernetes.io/docs/concepts/storage/storage-classes/
	// for more information on Kubernetes storage classes.
	StorageClass string `json:"storageClass,omitempty"`

	// Bootstrap describes the desired state of the guest's bootstrap
	// configuration.
	//
	// If omitted, a default bootstrap method may be selected based on the
	// guest OS identifier. If Linux, then the LinuxPrep method is used.
	Bootstrap *VirtualMachineBootstrapSpec `json:"bootstrap,omitempty"`

	// Network describes the desired network configuration for the VM.
	//
	// Please note this value may be omitted entirely and the VM will be
	// assigned a single, virtual network interface that is connected to the
	// Namespace's default network.
	Network *VirtualMachineNetworkSpec `json:"network,omitempty"`

	// PowerState describes the desired power state of a VirtualMachine.
	//
	// Please note this field may be omitted when creating a new VM and will
	// default to "PoweredOn." However, once the field is set to a non-empty
	// value, it may no longer be set to an empty value.
	//
	// Additionally, setting this value to "Suspended" is not supported when
	// creating a new VM. The valid values when creating a new VM are
	// "PoweredOn" and "PoweredOff." An empty value is also allowed on create
	// since this value defaults to "PoweredOn" for new VMs.
	PowerState VirtualMachinePowerState `json:"powerState,omitempty"`

	// PowerOffMode describes the desired behavior when powering off a VM.
	//
	// There are three, supported power off modes: Hard, Soft, and
	// TrySoft. The first mode, Hard, is the equivalent of a physical
	// system's power cord being ripped from the wall. The Soft mode
	// requires the VM's guest to have VM Tools installed and attempts to
	// gracefully shutdown the VM. Its variant, TrySoft, first attempts
	// a graceful shutdown, and if that fails or the VM is not in a powered off
	// state after five minutes, the VM is halted.
	//
	// If omitted, the mode defaults to TrySoft.
	PowerOffMode VirtualMachinePowerOpMode `json:"powerOffMode,omitempty"`

	// SuspendMode describes the desired behavior when suspending a VM.
	//
	// There are three, supported suspend modes: Hard, Soft, and
	// TrySoft. The first mode, Hard, is where vSphere suspends the VM to
	// disk without any interaction inside of the guest. The Soft mode
	// requires the VM's guest to have VM Tools installed and attempts to
	// gracefully suspend the VM. Its variant, TrySoft, first attempts
	// a graceful suspend, and if that fails or the VM is not in a put into
	// standby by the guest after five minutes, the VM is suspended.
	//
	// If omitted, the mode defaults to TrySoft.
	SuspendMode VirtualMachinePowerOpMode `json:"suspendMode,omitempty"`

	// NextRestartTime may be used to restart the VM, in accordance with
	// RestartMode, by setting the value of this field to "now"
	// (case-insensitive).
	//
	// A mutating webhook changes this value to the current time (UTC), which
	// the VM controller then uses to determine the VM should be restarted by
	// comparing the value to the timestamp of the last time the VM was
	// restarted.
	//
	// Please note it is not possible to schedule future restarts using this
	// field. The only value that users may set is the string "now"
	// (case-insensitive).
	NextRestartTime string `json:"nextRestartTime,omitempty"`

	// RestartMode describes the desired behavior for restarting a VM when
	// spec.nextRestartTime is set to "now" (case-insensitive).
	//
	// There are three, supported suspend modes: Hard, Soft, and
	// TrySoft. The first mode, Hard, is where vSphere resets the VM without any
	// interaction inside of the guest. The Soft mode requires the VM's guest to
	// have VM Tools installed and asks the guest to restart the VM. Its
	// variant, TrySoft, first attempts a soft restart, and if that fails or
	// does not complete within five minutes, the VM is hard reset.
	//
	// If omitted, the mode defaults to TrySoft.
	RestartMode VirtualMachinePowerOpMode `json:"restartMode,omitempty"`

	// Volumes describes a list of volumes that can be mounted to the VM.
	Volumes []VirtualMachineVolume `json:"volumes,omitempty"`

	// ReadinessProbe describes a probe used to determine the VM's ready state.
	ReadinessProbe *VirtualMachineReadinessProbeSpec `json:"readinessProbe,omitempty"`

	// Advanced describes a set of optional, advanced VM configuration options.
	Advanced *VirtualMachineAdvancedSpec `json:"advanced,omitempty"`

	// Reserved describes a set of VM configuration options reserved for system
	// use.
	//
	// Please note attempts to modify the value of this field by a DevOps user
	// will result in a validation error.
	Reserved *VirtualMachineReservedSpec `json:"reserved,omitempty"`

	// MinHardwareVersion describes the desired, minimum hardware version.
	//
	// The logic that determines the hardware version is as follows:
	//
	// 1. If this field is set, then its value is used.
	// 2. Otherwise, if the VirtualMachineClass used to deploy the VM contains a
	//    non-empty hardware version, then it is used.
	// 3. Finally, if the hardware version is still undetermined, the value is
	//    set to the default hardware version for the Datacenter/Cluster/Host
	//    where the VM is provisioned.
	//
	// This field is never updated to reflect the derived hardware version.
	// Instead, VirtualMachineStatus.HardwareVersion surfaces
	// the observed hardware version.
	//
	// Please note, setting this field's value to N ensures a VM's hardware
	// version is equal to or greater than N. For example, if a VM's observed
	// hardware version is 10 and this field's value is 13, then the VM will be
	// upgraded to hardware version 13. However, if the observed hardware
	// version is 17 and this field's value is 13, no change will occur.
	//
	// Several features are hardware version dependent, for example:
	//
	// * NVMe Controllers                >= 14
	// * Dynamic Direct Path I/O devices >= 17
	//
	// Please refer to https://kb.vmware.com/s/article/1003746 for a list of VM
	// hardware versions.
	//
	// It is important to remember that a VM's hardware version may not be
	// downgraded and upgrading a VM deployed from an image based on an older
	// hardware version to a more recent one may result in unpredictable
	// behavior. In other words, please be careful when choosing to upgrade a
	// VM to a newer hardware version.
	MinHardwareVersion int32 `json:"minHardwareVersion,omitempty"`

	// InstanceUUID describes the desired Instance UUID for a VM.
	// If omitted, this field defaults to a random UUID.
	// This value is only used for the VM Instance UUID,
	// it is not used within cloudInit.
	// This identifier is used by VirtualCenter to uniquely identify all
	// virtual machine instances, including those that may share the same BIOS UUID.
	InstanceUUID string `json:"instanceUUID,omitempty"`

	// BiosUUID describes the desired BIOS UUID for a VM.
	// If omitted, this field defaults to a random UUID.
	// When the bootstrap provider is Cloud-Init, this value is used as the
	// default value for spec.bootstrap.cloudInit.instanceID if it is omitted.
	BiosUUID string `json:"biosUUID,omitempty"`

	// GuestID describes the desired guest operating system identifier for a VM.
	//
	// The logic that determines the guest ID is as follows:
	//
	// If this field is set, then its value is used.
	// Otherwise, if the VM is deployed from an OVF template that defines a
	// guest ID, then that value is used.
	// The guest ID from VirtualMachineClass used to deploy the VM is ignored.
	//
	// For a complete list of supported values, refer to https://bit.ly/3TiZX3G.
	// Note that some guest ID values may require a minimal hardware version,
	// which can be set using the `spec.minHardwareVersion` field.
	// To see the mapping between virtual hardware versions and the product
	// versions that support a specific guest ID, visit the following link:
	// https://knowledge.broadcom.com/external/article/315655/virtual-machine-hardware-versions.html
	//
	// Please note that this field is immutable after the VM is powered on.
	// To change the guest ID after the VM is powered on, the VM must be powered
	// off and then powered on again with the updated guest ID spec.
	//
	// This field is required when the VM has any CD-ROM devices attached.
	GuestID string `json:"guestID,omitempty"`
}

type VirtualMachineStatus struct {

	// Class is a reference to the VirtualMachineClass resource used to deploy
	// this VM.
	Class *vmopv1common.LocalObjectRef `json:"class,omitempty"`

	// Host describes the hostname or IP address of the infrastructure host
	// where the VM is executed.
	Host string `json:"host,omitempty"`

	// PowerState describes the observed power state of the VirtualMachine.
	PowerState VirtualMachinePowerState `json:"powerState,omitempty"`

	// Conditions describes the observed conditions of the VirtualMachine.
	Conditions []metav1.Condition `json:"conditions,omitempty"`

	// Crypto describes the observed state of the VirtualMachine's encryption
	// configuration.
	Crypto *VirtualMachineCryptoStatus `json:"crypto,omitempty"`

	// Network describes the observed state of the VM's network configuration.
	// Please note much of the network status information is only available if
	// the guest has VM Tools installed.
	Network *VirtualMachineNetworkStatus `json:"network,omitempty"`

	// UniqueID describes a unique identifier that is provided by the underlying
	// infrastructure provider, such as vSphere.
	UniqueID string `json:"uniqueID,omitempty"`

	// BiosUUID describes a unique identifier provided by the underlying
	// infrastructure provider that is exposed to the Guest OS BIOS as a unique
	// hardware identifier.
	BiosUUID string `json:"biosUUID,omitempty"`

	// InstanceUUID describes the unique instance UUID provided by the
	// underlying infrastructure provider, such as vSphere.
	InstanceUUID string `json:"instanceUUID,omitempty"`

	// Volumes describes the observed state of the volumes that are intended to
	// be attached to the VirtualMachine.
	Volumes []VirtualMachineVolumeStatus `json:"volumes,omitempty"`

	// ChangeBlockTracking describes whether or not change block tracking is
	// enabled for the VirtualMachine.
	ChangeBlockTracking *bool `json:"changeBlockTracking,omitempty"`

	// Zone describes the availability zone where the VirtualMachine has been
	// scheduled.
	//
	// Please note this field may be empty when the cluster is not zone-aware.
	Zone string `json:"zone,omitempty"`

	// LastRestartTime describes the last time the VM was restarted.
	LastRestartTime *metav1.Time `json:"lastRestartTime,omitempty"`

	// HardwareVersion describes the VirtualMachine resource's observed
	// hardware version.
	//
	// Please refer to VirtualMachineSpec.MinHardwareVersion for more
	// information on the topic of a VM's hardware version.
	HardwareVersion int32 `json:"hardwareVersion,omitempty"`

	// Storage describes the observed state of the VirtualMachine's storage.
	Storage *VirtualMachineStorageStatus `json:"storage,omitempty"`
}

type VirtualMachineStorageStatus struct {

	// Committed is the total storage space committed to this VirtualMachine.
	Committed *resource.Quantity `json:"committed,omitempty"`

	// Uncommitted is the total storage space potentially used by this
	// VirtualMachine.
	Uncommitted *resource.Quantity `json:"uncommitted,omitempty"`

	// Unshared is the total storage space occupied by this VirtualMachine that
	// is not shared with any other VirtualMachine.
	Unshared *resource.Quantity `json:"unshared,omitempty"`
}

type VirtualMachineTemplate struct {

	// Net describes the observed state of the VM's network configuration.
	Net NetworkStatus

	// VM represents a pointer to a VirtualMachine instance that consist of the
	// desired specification and the observed status
	VM *VirtualMachine
}

type VirtualMachineTemplateSpec struct {
	// +optional
	//
	// ObjectMeta contains the desired Labels and Annotations that must be
	// applied to each replica virtual machine.
	vmopv1common.ObjectMeta `json:"metadata,omitempty"`

	// +optional
	//
	// Specification of the desired behavior of each replica virtual machine.
	Spec VirtualMachineSpec `json:"spec,omitempty"`
}

type VirtualMachineVolume struct {
	// Name represents the volume's name. Must be a DNS_LABEL and unique within
	// the VM.
	Name string `json:"name"`

	// VirtualMachineVolumeSource represents the location and type of a volume
	// to mount.
	VirtualMachineVolumeSource `json:",inline"`
}

type VirtualMachineVolumeCryptoStatus struct {

	// ProviderID describes the provider ID used to encrypt the volume.
	// Please note, this field will be empty if the volume is not
	// encrypted.
	ProviderID string `json:"providerID,omitempty"`

	// KeyID describes the key ID used to encrypt the volume.
	// Please note, this field will be empty if the volume is not
	// encrypted.
	KeyID string `json:"keyID,omitempty"`
}

type VirtualMachineVolumeProvisioningMode string

type VirtualMachineVolumeSource struct {

	// PersistentVolumeClaim represents a reference to a PersistentVolumeClaim
	// in the same namespace.
	//
	// More information is available at
	// https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims.
	PersistentVolumeClaim *PersistentVolumeClaimVolumeSource `json:"persistentVolumeClaim,omitempty"`
}

type VirtualMachineVolumeStatus struct {
	// Name is the name of the attached volume.
	Name string `json:"name"`

	// Type is the type of the attached volume.
	Type VirtualMachineVolumeType `json:"type"`

	// Crypto describes the volume's encryption status.
	Crypto *VirtualMachineVolumeCryptoStatus `json:"crypto,omitempty"`

	// Limit describes the storage limit for the volume.
	Limit *resource.Quantity `json:"limit,omitempty"`

	// Used describes the observed, non-shared size of the volume on disk.
	// For example, if this is a linked-clone's boot volume, this value
	// represents the space consumed by the linked clone, not the parent.
	Used *resource.Quantity `json:"used,omitempty"`

	// Attached represents whether a volume has been successfully attached to
	// the VirtualMachine or not.
	Attached bool `json:"attached,omitempty"`

	// DiskUUID represents the underlying virtual disk UUID and is present when
	// attachment succeeds.
	DiskUUID string `json:"diskUUID,omitempty"`

	// Error represents the last error seen when attaching or detaching a
	// volume.  Error will be empty if attachment succeeds.
	Error string `json:"error,omitempty"`
}

type VirtualMachineVolumeType string

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

	Spec   VirtualMachineWebConsoleRequestSpec   `json:"spec,omitempty"`
	Status VirtualMachineWebConsoleRequestStatus `json:"status,omitempty"`
}

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

type VirtualMachineWebConsoleRequestSpec struct {
	// Name is the name of a VM in the same Namespace as this web console
	// request.
	Name string `json:"name"`
	// PublicKey is used to encrypt the status.response. This is expected to be a RSA OAEP public key in X.509 PEM format.
	PublicKey string `json:"publicKey"`
}

type VirtualMachineWebConsoleRequestStatus struct {
	// Response will be the authenticated ticket corresponding to this web console request.
	Response string `json:"response,omitempty"`
	// ExpiryTime is the time at which access via this request will expire.
	ExpiryTime metav1.Time `json:"expiryTime,omitempty"`

	// ProxyAddr describes the host address and optional port used to access
	// the VM's web console.
	//
	// The value could be a DNS entry, IPv4, or IPv6 address, followed by an
	// optional port. For example, valid values include:
	//
	//     DNS
	//         * host.com
	//         * host.com:6443
	//
	//     IPv4
	//         * 1.2.3.4
	//         * 1.2.3.4:6443
	//
	//     IPv6
	//         * 1234:1234:1234:1234:1234:1234:1234:1234
	//         * [1234:1234:1234:1234:1234:1234:1234:1234]:6443
	//         * 1234:1234:1234:0000:0000:0000:1234:1234
	//         * 1234:1234:1234::::1234:1234
	//         * [1234:1234:1234::::1234:1234]:6443
	//
	// In other words, the field may be set to any value that is parsable
	// by Go's https://pkg.go.dev/net#ResolveIPAddr and
	// https://pkg.go.dev/net#ParseIP functions.
	ProxyAddr string `json:"proxyAddr,omitempty"`
}