v1alpha4

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 GroupMember struct {
	// Name is the name of member of this group.
	Name string `json:"name"`

	// Kind is the kind of member of this group, which can be either
	// VirtualMachine or VirtualMachineGroup.
	//
	// If omitted, it defaults to VirtualMachine.
	Kind string `json:"kind,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 QuiesceSpec struct {

	// Timeout represents the maximum time in minutes for snapshot
	// operation to be performed on the virtual machine. The timeout
	// can not be less than 5 minutes or more than 240 minutes.
	Timeout *metav1.Duration `json:"timeout,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 ResourcePoolStatus struct {
	ClusterMoID           string `json:"clusterMoID"`
	ChildResourcePoolMoID string `json:"childResourcePoolMoID"`
}

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 VMAffinityTerm struct {

	// LabelSelector is a label query over a set of VMs.
	// When omitted, this term matches with no VMs.
	LabelSelector *metav1.LabelSelector `json:"labelSelector,omitempty"`

	// TopologyKey describes where this VM should be co-located (affinity) or not
	// co-located (anti-affinity).
	// Commonly used values include:
	// `kubernetes.io/hostname` -- The rule is executed in the context of a node/host.
	// `topology.kubernetes.io/zone` -- This rule is executed in the context of a zone.
	//
	// Please note, The following rules apply when specifying the topology key in the context of a zone/host.
	//
	// - When topology key is in the context of a zone, the only supported verbs are
	//   PreferredDuringSchedulingIgnoredDuringExecution and RequiredDuringSchedulingIgnoredDuringExecution.
	// - When topology key is in the context of a host, the only supported verbs are
	//   PreferredDuringSchedulingPreferredDuringExecution and RequiredDuringSchedulingPreferredDuringExecution
	//   for VM-VM node-level anti-affinity scheduling.
	// - When topology key is in the context of a host, the only supported verbs are
	//   PreferredDuringSchedulingIgnoredDuringExecution and RequiredDuringSchedulingIgnoredDuringExecution
	//   for VM-VM node-level anti-affinity scheduling.
	TopologyKey string `json:"topologyKey"`
}

type VSphereClusterModuleStatus struct {
	GroupName   string `json:"groupName"`
	ModuleUuid  string `json:"moduleUUID"` //nolint:revive
	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 VirtualMachineAffinitySpec struct {

	// ZoneAffinity describes affinity scheduling rules related to a zone.
	ZoneAffinity *VirtualMachineAffinityZoneAffinitySpec `json:"zoneAffinity,omitempty"`

	// ZoneAntiAffinity describes anti-affinity scheduling rules related to a zone.
	ZoneAntiAffinity *VirtualMachineAntiAffinityZoneAffinitySpec `json:"zoneAntiAffinity,omitempty"`

	// VMAffinity describes affinity scheduling rules related to other VMs.
	VMAffinity *VirtualMachineAffinityVMAffinitySpec `json:"vmAffinity,omitempty"`

	// VMAntiAffinity describes anti-affinity scheduling rules related to other VMs.
	VMAntiAffinity *VirtualMachineAntiAffinityVMAffinitySpec `json:"vmAntiAffinity,omitempty"`
}

type VirtualMachineAffinityVMAffinitySpec struct {

	// RequiredDuringSchedulingIgnoredDuringExecution describes affinity
	// requirements that must be met or the VM will not be scheduled.
	//
	// When there are multiple elements, the lists of nodes corresponding to
	// each term are intersected, i.e. all terms must be satisfied.
	RequiredDuringSchedulingIgnoredDuringExecution []VMAffinityTerm `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty"`

	// PreferredDuringSchedulingIgnoredDuringExecution describes affinity
	// requirements that should be met, but the VM can still be scheduled if
	// the requirement cannot be satisfied. The scheduler will prefer to schedule VMs
	// that satisfy the anti-affinity expressions specified by this field, but it may choose to
	// violate one or more of the expressions.
	//
	// When there are multiple elements, the lists of nodes corresponding to
	// each term are intersected, i.e. all terms must be satisfied.
	PreferredDuringSchedulingIgnoredDuringExecution []VMAffinityTerm `json:"preferredDuringSchedulingIgnoredDuringExecution,omitempty"`
}

type VirtualMachineAffinityZoneAffinitySpec struct {

	// RequiredDuringSchedulingIgnoredDuringExecution describes affinity
	// requirements that must be met or the VM will not be scheduled.
	//
	// When there are multiple elements, the lists of zones corresponding to
	// each term are intersected, i.e. all terms must be satisfied.
	RequiredDuringSchedulingIgnoredDuringExecution []ZoneSelectorTerm `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty"`

	// PreferredDuringSchedulingIgnoredDuringExecution describes affinity
	// requirements that should be met, but the VM can still be scheduled if
	// the requirement cannot be satisfied. The scheduler will prefer to schedule VMs
	// that satisfy the anti-affinity expressions specified by this field, but it may choose to
	// violate one or more of the expressions.
	//
	// When there are multiple elements, the lists of zones corresponding to
	// each term are intersected, i.e. all terms must be satisfied.
	PreferredDuringSchedulingIgnoredDuringExecution []ZoneSelectorTerm `json:"preferredDuringSchedulingIgnoredDuringExecution,omitempty"`
}

type VirtualMachineAntiAffinityVMAffinitySpec struct {

	// RequiredDuringSchedulingIgnoredDuringExecution describes anti-affinity
	// requirements that must be met or the VM will not be scheduled.
	//
	// When there are multiple elements, the lists of nodes corresponding to
	// each term are intersected, i.e. all terms must be satisfied.
	RequiredDuringSchedulingIgnoredDuringExecution []VMAffinityTerm `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty"`

	// PreferredDuringSchedulingIgnoredDuringExecution describes anti-affinity
	// requirements that should be met, but the VM can still be scheduled if
	// the requirement cannot be satisfied. The scheduler will prefer to schedule VMs
	// that satisfy the affinity expressions specified by this field, but it may choose to
	// violate one or more of the expressions.
	//
	// When there are multiple elements, the lists of nodes corresponding to
	// each term are intersected, i.e. all terms must be satisfied.
	PreferredDuringSchedulingIgnoredDuringExecution []VMAffinityTerm `json:"preferredDuringSchedulingIgnoredDuringExecution,omitempty"`

	// RequiredDuringSchedulingPreferredExecution describes anti-affinity
	// requirements that must be met or the VM will not be scheduled. Additionally,
	// it also describes the anti-affinity requirements that should be met during run-time,
	// but the VM can still be run if the requirements cannot be satisfied.
	//
	// When there are multiple elements, the lists of nodes corresponding to
	// each term are intersected, i.e. all terms must be satisfied.
	RequiredDuringSchedulingPreferredDuringExecution []VMAffinityTerm `json:"requiredDuringSchedulingPreferredDuringExecution,omitempty"`

	// PreferredDuringSchedulingPreferredDuringExecution describes anti-affinity
	// requirements that should be met, but the VM can still be scheduled if
	// the requirement cannot be satisfied. The scheduler will prefer to schedule VMs
	// that satisfy the affinity expressions specified by this field, but it may choose to
	// violate one or more of the expressions. Additionally,
	// it also describes the anti-affinity requirements that should be met during run-time,
	// but the VM can still be run if the requirements cannot be satisfied.
	//
	// When there are multiple elements, the lists of nodes corresponding to
	// each term are intersected, i.e. all terms must be satisfied.
	PreferredDuringSchedulingPreferredDuringExecution []VMAffinityTerm `json:"preferredDuringSchedulingPreferredDuringExecution,omitempty"`
}

type VirtualMachineAntiAffinityZoneAffinitySpec struct {

	// RequiredDuringSchedulingIgnoredDuringExecution describes affinity
	// requirements that must be met or the VM will not be scheduled.
	//
	// When there are multiple elements, the lists of zones corresponding to
	// each term are intersected, i.e. all terms must be satisfied.
	RequiredDuringSchedulingIgnoredDuringExecution []ZoneSelectorTerm `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty"`

	// PreferredDuringSchedulingIgnoredDuringExecution describes affinity
	// requirements that should be met, but the VM can still be scheduled if
	// the requirement cannot be satisfied. The scheduler will prefer to schedule VMs to
	// that satisfy the anti-affinity expressions specified by this field, but it may choose to
	// violate one or more of the expressions.
	//
	// When there are multiple elements, the lists of zones corresponding to
	// each term are intersected, i.e. all terms must be satisfied.
	PreferredDuringSchedulingIgnoredDuringExecution []ZoneSelectorTerm `json:"preferredDuringSchedulingIgnoredDuringExecution,omitempty"`
}

type VirtualMachineBootOptions struct {

	// Firmware represents the firmware for the virtual machine to use. Any update
	// to this value after the virtual machine has already been created will be
	// ignored. Setting will happen in the following manner:
	//
	// 1. If this value is specified, it will be used to set the VM firmware. If this
	//    value is unset, then
	// 2. the virtual machine image will be checked. If that value is set, then it will
	//    be used to set the VM firmware. If that value is unset, then
	// 3. the virtual machine class will be checked. If that value is set, then it will
	//    be used to set the VM firmware. If that value is unset, then
	// 4. the VM firmware will be set, by default, to BIOS.
	//
	// The available values of this field are:
	//
	// - BIOS
	// - EFI
	Firmware VirtualMachineBootOptionsFirmwareType `json:"firmware,omitempty"`

	// BootDelay is the delay before starting the boot sequence. The boot delay
	// specifies a time interval between virtual machine power on or restart and
	// the beginning of the boot sequence.
	BootDelay *metav1.Duration `json:"bootDelay,omitempty"`

	// BootOrder represents the boot order of the virtual machine. After list is exhausted,
	// default BIOS boot device algorithm is used for booting. Note that order of the entries
	// in the list is important: device listed first is used for boot first, if that one
	// fails second entry is used, and so on. Platform may have some internal limit on the
	// number of devices it supports. If bootable device is not reached before platform's limit
	// is hit, boot will fail. At least single entry is supported by all products supporting
	// boot order settings.
	//
	// The available devices are:
	//
	// - Disk    -- If there are classic and managed disks, the first classic disk is selected.
	//              If there are only managed disks, the first disk is selected.
	// - Network -- The first interface listed in spec.network.interfaces.
	// - CDRom   -- The first bootable CD-ROM device.
	BootOrder []VirtualMachineBootOptionsBootableDevice `json:"bootOrder,omitempty"`

	// BootRetry specifies whether a virtual machine that fails to boot
	// will try again. The available values are:
	//
	// - Enabled -- A virtual machine that fails to boot will try again
	//              after BootRetryDelay time period has expired.
	// - Disabled -- The virtual machine waits indefinitely for you to
	//               initiate boot retry.
	BootRetry VirtualMachineBootOptionsBootRetry `json:"bootRetry,omitempty"`

	// BootRetryDelay specifies a time interval between virtual machine boot failure
	// and the subsequent attempt to boot again. The virtual machine uses this value
	// only if BootRetry is Enabled.
	BootRetryDelay *metav1.Duration `json:"bootRetryDelay,omitempty"`

	// EnterBootSetup specifies whether to automatically enter BIOS/EFI setup the next
	// time the virtual machine boots. The virtual machine resets this flag to false
	// so that subsequent boots proceed normally. The available values are:
	//
	// - Enabled -- The virtual machine will automatically enter BIOS/EFI setup the next
	//              time the virtual machine boots.
	// - Disabled -- The virtual machine will boot normaally.
	EnterBootSetup VirtualMachineBootOptionsForceBootEntry `json:"enterBootSetup,omitempty"`

	// EFISecureBoot specifies whether the virtual machine's firmware will
	// perform signature checks of any EFI images loaded during startup. If set to
	// true, signature checks will be performed and the virtual machine's firmware
	// will refuse to start any images which do not pass those signature checks.
	//
	// Please note, this field will not be honored unless the value of
	// spec.bootOptions.firmware is "EFI". The available values are:
	//
	// - Enabled -- Signature checks will be performed and the virtual machine's firmware
	//              will refuse to start any images which do not pass those signature checks.
	// - Disabled -- No signature checks will be performed.
	EFISecureBoot VirtualMachineBootOptionsEFISecureBoot `json:"efiSecureBoot,omitempty"`

	// NetworkBootProtocol is the protocol to attempt during PXE network boot or NetBoot.
	// The available protocols are:
	//
	// - IP4 -- PXE (or Apple NetBoot) over IPv4. The default.
	// - IP6 -- PXE over IPv6. Only meaningful for EFI virtual machines.
	NetworkBootProtocol VirtualMachineBootOptionsNetworkBootProtocol `json:"networkBootProtocol,omitempty"`
}

type VirtualMachineBootOptionsBootRetry string

type VirtualMachineBootOptionsBootableDevice string

type VirtualMachineBootOptionsEFISecureBoot string

type VirtualMachineBootOptionsFirmwareType string

type VirtualMachineBootOptionsForceBootEntry string

type VirtualMachineBootOptionsNetworkBootProtocol string

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"`

	// WaitOnNetwork4 indicates whether the cloud-init datasource should wait
	// for an IPv4 address to be available before writing the instance-data.
	//
	// When set to true, the cloud-init datasource will sleep for a second,
	// check network status, and repeat until an IPv4 address is available.
	WaitOnNetwork4 *bool `json:"waitOnNetwork4,omitempty"`

	// WaitOnNetwork6 indicates whether the cloud-init datasource should wait
	// for an IPv6 address to be available before writing the instance-data.
	//
	// When set to true, the cloud-init datasource will sleep for a second,
	// check network status, and repeat until an IPv6 address is available.
	WaitOnNetwork6 *bool `json:"waitOnNetwork6,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 VirtualMachineClassInstance struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   VirtualMachineClassInstanceSpec   `json:"spec,omitempty"`
	Status VirtualMachineClassInstanceStatus `json:"status,omitempty"`
}

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

type VirtualMachineClassInstanceSpec struct {
	VirtualMachineClassSpec `json:",inline"`
}

type VirtualMachineClassInstanceStatus struct {
}

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 VirtualMachineDeployMode string

type VirtualMachineEncryptionType string

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

	Spec   VirtualMachineGroupSpec   `json:"spec,omitempty"`
	Status VirtualMachineGroupStatus `json:"status,omitempty"`
}

type VirtualMachineGroupBootOrderGroup struct {

	// Members describes the names of VirtualMachine or VirtualMachineGroup
	// objects that are members of this boot order group. The VM or VM Group
	// objects must be in the same namespace as this group.
	Members []GroupMember `json:"members,omitempty"`

	// PowerOnDelay is the amount of time to wait before powering on all the
	// members of this boot order group.
	//
	// If omitted, the members will be powered on immediately when the group's
	// power state changes to PoweredOn.
	PowerOnDelay *metav1.Duration `json:"powerOnDelay,omitempty"`
}

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

type VirtualMachineGroupMemberStatus struct {
	// Name is the name of this member.
	Name string `json:"name"`

	// Kind is the kind of this member, which can be either VirtualMachine or
	// VirtualMachineGroup.
	Kind string `json:"kind"`

	// Placement describes the placement results for this member.
	//
	// Please note this field is only set for VirtualMachine members.
	Placement *VirtualMachinePlacementStatus `json:"placement,omitempty"`

	// PowerState describes the observed power state of this member.
	//
	// Please note this field is only set for VirtualMachine members.
	PowerState *VirtualMachinePowerState `json:"powerState,omitempty"`

	// Conditions describes any conditions associated with this member.
	//
	// - The GroupLinked condition is True when the member exists and has its
	//   "Spec.GroupName" field set to the group's name.
	// - The PowerStateSynced condition is True for the VirtualMachine member
	//   when the member's power state matches the group's power state.
	// - The PlacementReady condition is True for the VirtualMachine member
	//   when the member has a placement decision ready.
	// - The ReadyType condition is True for the VirtualMachineGroup member
	//   when all of its members' conditions are True.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type VirtualMachineGroupPlacementDatastoreStatus struct {
	// Name describes the name of a datastore.
	Name string `json:"name"`

	// ID describes the datastore ID.
	ID string `json:"id,omitempty"`

	// URL describes the datastore URL.
	URL string `json:"url,omitempty"`

	// SupportedDiskFormat describes the list of disk formats supported by this
	// datastore.
	SupportedDiskFormats []string `json:"supportedDiskFormats,omitempty"`

	// DiskKey describes the device key to which this recommendation applies.
	// When omitted, this recommendation is for the VM's home directory.
	DiskKey *int32 `json:"diskKey,omitempty"`
}

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

	Spec   VirtualMachineGroupPublishRequestSpec   `json:"spec,omitempty"`
	Status VirtualMachineGroupPublishRequestStatus `json:"status,omitempty"`
}

type VirtualMachineGroupPublishRequestImageStatus struct {

	// Source is the name of the published VirtualMachine.
	Source string `json:"source"`

	// PublishRequestName is the name of the VirtualMachinePublishRequest object
	// created to publish the VM.
	PublishRequestName string `json:"publishRequestName"`

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

	// Conditions is a copy of the conditions from the
	// VirtualMachinePublishRequest object created to publish the VM.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

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

type VirtualMachineGroupPublishRequestSpec struct {

	// Source is the name of the VirtualMachineGroup to be published.
	//
	// If this value is omitted then the publication controller checks to
	// see if there is a VirtualMachineGroup with the same name as this
	// VirtualMachineGroupPublishRequest resource. If such a resource exists,
	// then it is the source of the publication.
	Source string `json:"source,omitempty"`

	// VirtualMachines is a list of the VirtualMachine objects from the source
	// VirtualMachineGroup that are included in this publish request.
	//
	// If omitted, this field defaults to the names of all of the VMs currently
	// a member of the group, either directly or indirectly via a nested group.
	VirtualMachines []string `json:"virtualMachines,omitempty"`

	// Target is the name of the ContentLibrary resource to which the
	// VirtualMachines from the VirtualMachineGroup should be published.
	//
	// When this value is omitted, the controller attempts to identify the
	// target location by matching a ContentLibrary resource with the label
	// "imageregistry.vmware.com/default".
	//
	// Please note that while optional, if a VirtualMachineGroupPublishRequest
	// sans target information is applied to a namespace without a default
	// publication target, then the VirtualMachineGroupPublishRequest resource
	// will be marked in error.
	Target string `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.
	// This will be passed into each VirtualMachinePublishRequestSpec.
	//
	// 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 VirtualMachineGroupPublishRequestStatus struct {

	// Source is the name of the published VirtualMachineGroup.
	Source string `json:"source,omitempty"`

	// Target is the name of the ContentLibrary to which the group is published.
	Target string `json:"target,omitempty"`

	// CompletionTime represents 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 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.
	//
	// Please note that the group will not be published until the group's Ready
	// condition is true.
	StartTime metav1.Time `json:"startTime,omitempty"`

	// Images describes the observed status of the individual VirtualMachine
	// publications.
	Images []VirtualMachineGroupPublishRequestImageStatus `json:"images,omitempty"`

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

type VirtualMachineGroupSpec struct {

	// GroupName describes the name of the group that this group belongs to.
	//
	// If omitted, this group is not a member of any other group.
	GroupName string `json:"groupName,omitempty"`

	// BootOrder describes the boot sequence for this group members. Each boot
	// order contains a set of members that will be powered on simultaneously,
	// with an optional delay before powering on. The orders are processed
	// sequentially in the order they appear in this list, with delays being
	// cumulative across orders.
	//
	// When powering off, all members are stopped immediately without delays.
	BootOrder []VirtualMachineGroupBootOrderGroup `json:"bootOrder,omitempty"`

	// PowerState describes the desired power state of a VirtualMachineGroup.
	//
	// Please note this field may be omitted when creating a new VM group. This
	// ensures that the power states of any existing VMs that are added to the
	// group do not have their power states changed until the group's power
	// state is explicitly altered.
	//
	// However, once the field is set to a non-empty value, it may no longer be
	// set to an empty value. This means that if the group's power state is
	// PoweredOn, and a VM whose power state is PoweredOff is added to the
	// group, that VM will be powered on.
	PowerState VirtualMachinePowerState `json:"powerState,omitempty"`

	// NextForcePowerStateSyncTime may be used to force sync the power state of
	// the group to all of its members, 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 Group controller then uses to trigger a sync of the group's power
	// state to its members.
	//
	// Please note it is not possible to schedule future syncs using this field.
	// The only value that users may set is the string "now" (case-insensitive).
	NextForcePowerStateSyncTime string `json:"nextForcePowerStateSyncTime,omitempty"`

	// PowerOffMode describes the desired behavior when powering off a VM Group.
	// Refer to the VirtualMachine.PowerOffMode field for more details.
	//
	// Please note this field is only propagated to the group's members when
	// the group's power state is changed or the nextForcePowerStateSyncTime
	// field is set to "now".
	PowerOffMode VirtualMachinePowerOpMode `json:"powerOffMode,omitempty"`

	// SuspendMode describes the desired behavior when suspending a VM Group.
	// Refer to the VirtualMachine.SuspendMode field for more details.
	//
	// Please note this field is only propagated to the group's members when
	// the group's power state is changed or the nextForcePowerStateSyncTime
	// field is set to "now".
	SuspendMode VirtualMachinePowerOpMode `json:"suspendMode,omitempty"`
}

type VirtualMachineGroupStatus struct {

	// Members describes the observed status of group members.
	Members []VirtualMachineGroupMemberStatus `json:"members,omitempty"`

	// LastUpdatedPowerStateTime describes the observed time when the power
	// state of the group was last updated.
	LastUpdatedPowerStateTime *metav1.Time `json:"lastUpdatedPowerStateTime,omitempty"`

	// Conditions describes any conditions associated with this VM Group.
	//
	// - The ReadyType condition is True when all of the group members have
	//   all of their expected conditions set to True.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

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 VirtualMachineImageCache struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   VirtualMachineImageCacheSpec   `json:"spec,omitempty"`
	Status VirtualMachineImageCacheStatus `json:"status,omitempty"`
}

type VirtualMachineImageCacheFileStatus struct {

	// ID describes the value used to locate the file.
	// The value of this field depends on the type of file:
	//
	// - Type=Other                  -- The ID value describes a datastore path,
	//                                  ex. "[my-datastore-1] .contentlib-cache/1234/5678/my-disk-1.vmdk"
	// - Type=Disk, DiskType=Classic -- The ID value describes a datastore
	//                                  path.
	// - Type=Disk, DiskType=Managed -- The ID value describes a First Class
	//                                  Disk (FCD).
	ID string `json:"id"`

	// Type describes the type of file.
	Type VirtualMachineImageCacheFileType `json:"type"`

	// DiskType describes the type of disk.
	// This field is only non-empty when Type=Disk.
	DiskType VirtualMachineVolumeType `json:"diskType,omitempty"`
}

type VirtualMachineImageCacheFileType string

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

type VirtualMachineImageCacheLocationSpec struct {
	// DatacenterID describes the ID of the datacenter to which the image should
	// be cached.
	DatacenterID string `json:"datacenterID"`

	// DatastoreID describes the ID of the datastore to which the image should
	// be cached.
	DatastoreID string `json:"datastoreID"`
}

type VirtualMachineImageCacheLocationStatus struct {

	// DatacenterID describes the ID of the datacenter to which the image should
	// be cached.
	DatacenterID string `json:"datacenterID"`

	// DatastoreID describes the ID of the datastore to which the image should
	// be cached.
	DatastoreID string `json:"datastoreID"`

	// Files describes the image's files cached on this datastore.
	Files []VirtualMachineImageCacheFileStatus `json:"files,omitempty"`

	// Conditions describes any conditions associated with this cache location.
	//
	// Generally this should just include the ReadyType condition.
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type VirtualMachineImageCacheOVFStatus struct {

	// ConfigMapName describes the name of the ConfigMap resource that contains
	// the image's OVF envelope encoded as YAML. The data is located in the
	// ConfigMap key "value".
	ConfigMapName string `json:"configMapName,omitempty"`

	// ProviderVersion describes the observed provider version at which the OVF
	// is cached.
	// The provider is Content Library, the version is the content version.
	ProviderVersion string `json:"providerVersion,omitempty"`
}

type VirtualMachineImageCacheSpec struct {
	// ProviderID describes the ID of the provider item to which the image
	// corresponds.
	// If the provider is Content Library, the ID refers to a Content Library
	// item.
	ProviderID string `json:"providerID"`

	// ProviderVersion describes the version of the provider item to which the
	// image corresponds.
	// The provider is Content Library, the version is the content version.
	ProviderVersion string `json:"providerVersion"`

	// Locations describes the locations where the image should be cached.
	Locations []VirtualMachineImageCacheLocationSpec `json:"locations,omitempty"`
}

type VirtualMachineImageCacheStatus struct {

	// Locations describe the observed locations where the image is cached.
	Locations []VirtualMachineImageCacheLocationStatus `json:"locations,omitempty"`

	// OVF describes the observed status of the cached OVF content.
	OVF *VirtualMachineImageCacheOVFStatus `json:"ovf,omitempty"`

	// Conditions describes any conditions associated with this cached image.
	//
	// Generally this should just include the ReadyType condition, which will
	// only be True if all of the cached locations also have True ReadyType
	// condition.
	Conditions []metav1.Condition `json:"conditions,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.
	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.
	//
	// If unset, the gateway from the network provider will be used. However,
	// if set to "None", the network provider gateway will be ignored.
	//
	// Please note this field is only supported if the network connection
	// supports manual IP allocation.
	//
	// 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.
	//
	// If unset, the gateway from the network provider will be used. However,
	// if set to "None", the network provider gateway will be ignored.
	//
	// Please note this field is only supported if the network connection
	// supports manual IP allocation.
	//
	// 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 either "default", or 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,omitempty"`
}

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 note 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"`

	// HostName describes the observed hostname reported by the VirtualMachine's
	// guest operating system.
	//
	// Please note, this value is only reported if VMware Tools is installed in
	// the guest, and the value may or may not be a fully qualified domain name
	// (FQDN), it simply depends on what is reported by the guest.
	HostName string `json:"hostName,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 VirtualMachineOrGroup interface {
	metav1.Object
	runtime.Object
	DeepCopyObject() runtime.Object
	GetGroupName() string
	SetGroupName(value string)
	GetPowerState() VirtualMachinePowerState
	SetPowerState(value VirtualMachinePowerState)
	GetConditions() []metav1.Condition
}

type VirtualMachinePlacementStatus struct {
	// Name is the name of VirtualMachine member of this group.
	Name string `json:"name"`

	// Zone describes the recommended zone for this VM.
	Zone string `json:"zoneID,omitempty"`

	// Node describes the recommended node for this VM.
	Node string `json:"node,omitempty"`

	// Pool describes the recommended resource pool for this VM.
	Pool string `json:"pool,omitempty"`

	// Datastores describe the recommended datastores for this VM.
	Datastores []VirtualMachineGroupPlacementDatastoreStatus `json:"datastores,omitempty"`
}

type VirtualMachinePowerOpMode string

type VirtualMachinePowerState string

type VirtualMachinePromoteDisksMode 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"`
}