v1alpha2

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

	// +optional
	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.
	// +kubebuilder:validation:Optional
	// +kubebuilder:default=green
	// +kubebuilder:validation:Enum=yellow;green
	ThresholdStatus GuestHeartbeatStatus `json:"thresholdStatus,omitempty"`
}

type GuestHeartbeatStatus string

type GuestInfoAction struct {
	// Key is the name of the GuestInfo key.
	//
	// Values are 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.
	//
	// +optional
	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.
	// +optional
	IP string `json:"ip,omitempty"`

	// Hostname is set for load balancer ingress points that are specified by a
	// DNS address.
	// +optional
	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.
	// +optional
	Ingress []LoadBalancerIngress `json:"ingress,omitempty"`
}

type NetworkDeviceStatus struct {
	// Gateway4 is the gateway for the IPv4 address family for this device.
	// +optional
	Gateway4 string

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

	// IpAddresses represents one or more IP addresses assigned to the network
	// device in CIDR notation, ex. "192.0.2.1/16".
	// +optional
	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.
	// +optional
	Devices []NetworkDeviceStatus

	// Nameservers describe a list of the DNS servers accessible by one of the
	// VM's configured network devices.
	// +optional
	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.
	// +optional
	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.
	// +optional
	InstanceVolumeClaim *InstanceVolumeClaimVolumeSource `json:"instanceVolumeClaim,omitempty"`
}

type ResourcePoolSpec struct {
	// Name describes the name of the ResourcePool grouping.
	// +optional
	Name string `json:"name,omitempty"`

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

	// Limits describes the limit to resources available to the ResourcePool.
	// +optional
	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.
	// +optional
	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.
	//
	// +optional
	BootDiskCapacity resource.Quantity `json:"bootDiskCapacity,omitempty"`

	// DefaultVolumeProvisioningMode specifies the default provisioning mode for
	// persistent volumes managed by this VM.
	//
	// +optional
	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.
	//
	// +optional
	ChangeBlockTracking bool `json:"changeBlockTracking,omitempty"`
}

type VirtualMachineBootstrapCloudInitSpec struct {

	// CloudConfig describes a subset of a Cloud-Init CloudConfig, used to
	// bootstrap the VM.
	//
	// Please note this field and RawCloudConfig are mutually exclusive.
	//
	// +optional
	CloudConfig cloudinit.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.
	//
	// +optional
	RawCloudConfig corev1.SecretKeySelector `json:"rawCloudConfig,omitempty"`

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

type VirtualMachineBootstrapLinuxPrepSpec struct {
	// HardwareClockIsUTC specifies whether the hardware clock is in UTC or
	// local time.
	//
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +optional
	Sysprep sysprep.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.
	//
	// +optional
	RawSysprep corev1.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.
	//
	// +optional
	// +listType=map
	// +listMapKey=key
	Properties []common.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.
	//
	// +optional
	RawProperties string `json:"rawProperties,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.
	//
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +optional
	// +kubebuilder:validation:Schemaless
	// +kubebuilder:validation:Type=object
	// +kubebuilder:pruning:PreserveUnknownFields
	ConfigSpec json.RawMessage `json:"configSpec,omitempty"`
}

type VirtualMachineClassStatus struct {
	// Capabilities describes the class's observed capabilities.
	//
	// The capabilities are discerned when VM Operator reconciles a class
	// and inspects its specification. Well-known capabilities include:
	//
	// * instance-storage
	// * nvidia-gpu
	// * sriov-net
	//
	// In addition to "nvidia-gpu", a capability is added for every nVidia
	// profile name associated with the class.
	//
	// Every capability is also added to the resource's labels as
	// VirtualMachineClassCapabilityLabel + Value. For example, if the
	// capability is "nvidia-gpu" then the following label will be added to the
	// resource: capability.class.vmoperator.vmware.com/nvidia-gpu.
	//
	// +optional
	// +listType=set
	Capabilities []string `json:"capabilities,omitempty"`

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

	// Ready describes whether the class's hardware can be realized in the
	// cluster.
	//
	// This field is only set to true if all of the class resource's conditions
	// have Status=True.
	//
	// +optional
	Ready bool `json:"ready,omitempty"`
}

type VirtualMachineConfigSpec struct {
	// XML contains a vim.vm.ConfigSpec object that has been serialized to XML
	// and base64-encoded.
	//
	// +optional
	XML string `json:"xml,omitempty"`
}

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

	Spec   VirtualMachineImageSpec   `json:"spec,omitempty"`
	Status VirtualMachineImageStatus `json:"status,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.
	//
	// +optional
	ID string `json:"id,omitempty"`

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

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

type VirtualMachineImageProductInfo struct {
	// Product is a general descriptor for the image.
	// +optional
	Product string `json:"product,omitempty"`

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

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

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

type VirtualMachineImageSpec struct {
	// ProviderRef is a reference to the resource that contains the source of
	// this image's information.
	//
	// +optional
	ProviderRef common.LocalObjectRef `json:"providerRef,omitempty"`
}

type VirtualMachineImageStatus struct {

	// Name describes the observed, "friendly" name for this image.
	//
	// +optional
	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.
	//
	// +optional
	// +listType=set
	Capabilities []string `json:"capabilities,omitempty"`

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

	// HardwareVersion describes the observed hardware version of this image.
	//
	// +optional
	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.
	//
	//
	// +optional
	OSInfo VirtualMachineImageOSInfo `json:"osInfo,omitempty"`

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

	// ProductInfo describes the observed product information for this image.
	// +optional
	ProductInfo VirtualMachineImageProductInfo `json:"productInfo,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.
	// +optional
	ProviderContentVersion string `json:"providerContentVersion,omitempty"`

	// Conditions describes the observed conditions for this image.
	//
	// +optional
	// +listType=map
	// +listMapKey=type
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

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

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;'.
	//
	// +optional
	// +listType=map
	// +listMapKey=key
	Config []common.KeyValuePair `json:"config,omitempty"`

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

type VirtualMachineNetworkDHCPStatus struct {

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

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

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

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

	// HostName is the host name portion of the DNS name. For example,
	// the "my-vm" part of "my-vm.domain.local".
	//
	// +optional
	HostName string `json:"hostName,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.
	//
	// +optional
	Nameservers []string `json:"nameservers,omitempty"`

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

type VirtualMachineNetworkIPRouteGatewayStatus struct {
	// Device is the name of the device in the guest for which this gateway
	// applies.
	//
	// +optional
	Device string `json:"device,omitempty"`

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

type VirtualMachineNetworkIPRouteStatus struct {
	// Gateway describes where to send the packets to next.
	Gateway VirtualMachineNetworkIPRouteGatewayStatus `json:"gateway"`

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

type VirtualMachineNetworkIPStackStatus struct {
	// DHCP describes the VM's observed, client-side, system-wide DHCP options.
	//
	// +optional
	DHCP VirtualMachineNetworkDHCPStatus `json:"dhcp,omitempty"`

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

	// IPRoutes contain the VM's routing tables for all address families.
	//
	// +optional
	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'.
	//
	// +optional
	// +listType=map
	// +listMapKey=key
	KernelConfig []common.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"`

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

	// Origin describes how this address was configured.
	//
	// +optional
	// +kubebuilder:validation:Enum=dhcp;linklayer;manual;other;random
	Origin string `json:"origin,omitempty"`

	// State describes the state of this IP address.
	//
	// +optional
	// +kubebuilder:validation:Enum=deprecated;duplicate;inaccessible;invalid;preferred;tentative;unknown
	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.
	//
	// +optional
	AutoConfigurationEnabled *bool `json:"autoConfigurationEnabled,omitempty"`

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

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

	// MACAddr describes the observed MAC address for this interface.
	//
	// +optional
	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.
	//
	// This value is also used to rename the device inside the guest when the
	// bootstrap provider is CloudInit. 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.
	//
	// +kubebuilder:validation:Pattern=^\w\w+$
	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.
	//
	// +optional
	Network common.PartialObjectRef `json:"network,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.
	//
	// +optional
	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.
	//
	// +optional
	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 IP4 addresses in the
	// Addresses field and the Gateway6 field.
	//
	// +optional
	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.
	//
	// +optional
	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 IP4 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.
	//
	// +optional
	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.
	//
	// +optional
	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, LinuxPrep, and Sysprep (except for RawSysprep).
	//
	// Please note that Linux allows only three nameservers
	// (https://linux.die.net/man/5/resolv.conf).
	//
	// +optional
	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.
	//
	// +optional
	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, LinuxPrep, and Sysprep (except for RawSysprep).
	//
	// +optional
	SearchDomains []string `json:"searchDomains,omitempty"`
}

type VirtualMachineNetworkInterfaceStatus struct {
	// Name describes the unique name of this network interface, used to
	// distinguish it from other network interfaces attached to this VM.
	//
	// Please note this name is not related to the name of the device as it is
	// surfaced inside of the guest.
	Name string `json:"name"`

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

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

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

	// Via is an IP4 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.
	//
	// +optional
	IPRoutes []VirtualMachineNetworkIPRouteStatus `json:"ipRoutes,omitempty"`
}

type VirtualMachineNetworkSpec struct {
	// Network is the optional name of the network resource to which this
	// VM is connected.
	//
	// Please note if the Interfaces field is non-empty then this field is
	// ignored.
	//
	// If networking is not disabled, no interfaces are defined, and this value
	// is omitted, then the VM will be provided a single virtual network
	// interface and connected to the Namespace's default network.
	//
	// +optional
	Network *common.PartialObjectRef `json:"network,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.
	//
	// +optional
	Disabled bool `json:"disabled,omitempty"`

	// HostName is the value the guest uses as its host name.
	// If omitted then the name of the VM will be used.
	//
	// Please note this feature is available only with the following bootstrap
	// providers: CloudInit, LinuxPrep, and Sysprep (except for RawSysprep).
	//
	// +optional
	HostName string `json:"hostName,omitempty"`

	// Interfaces is the list of network interfaces used by this VM.
	//
	// Please note this field is mutually exclusive with the following fields:
	// DeviceName, Network, Addresses, DHCP4, DHCP6, Gateway4,
	// Gateway6, MTU, Nameservers, Routes, and SearchDomains.
	//
	// +optional
	// +listType=map
	// +listMapKey=name
	Interfaces []VirtualMachineNetworkInterfaceSpec `json:"interfaces,omitempty"`

	// DeviceName describes the unique name of this network interface, used to
	// distinguish it from other network interfaces attached to this VM.
	//
	// This value is also used to rename the device inside the guest when the
	// bootstrap provider is CloudInit. 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.
	//
	// 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.
	//
	// If the Interfaces field is empty and this field is not specified, then
	// the default interface's name will be eth0.
	//
	// +optional
	// +kubebuilder:validation:Pattern=^\w\w+$
	DeviceName string `json:"deviceName,omitempty"`

	// Addresses is an optional list of IP4 or IP6 addresses to assign to the
	// VM.
	//
	// 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.
	//
	// +optional
	Addresses []string `json:"addresses,omitempty"`

	// DHCP4 indicates whether or not to use 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.
	//
	// 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.
	//
	// +optional
	DHCP4 bool `json:"dhcp4,omitempty"`

	// DHCP6 indicates whether or not to use 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 IP4 addresses in the
	// Addresses field and the Gateway6 field.
	//
	// 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.
	//
	// +optional
	DHCP6 bool `json:"dhcp6,omitempty"`

	// Gateway4 is the default, IP4 gateway for this VM.
	//
	// 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.
	//
	// 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.
	//
	// +optional
	Gateway4 string `json:"gateway4,omitempty"`

	// Gateway6 is the primary IP6 gateway for this VM.
	//
	// 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.
	// 2001:db8:101::1/64.
	//
	// Please note this field is mutually exclusive with DHCP6.
	//
	// 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.
	//
	// +optional
	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.
	//
	// 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.
	//
	// +optional
	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, LinuxPrep, and Sysprep (except for RawSysprep).
	//
	// Please note that Linux allows only three nameservers
	// (https://linux.die.net/man/5/resolv.conf).
	//
	// 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.
	//
	// +optional
	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.
	//
	// 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.
	//
	// +optional
	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, LinuxPrep, and Sysprep (except for RawSysprep).
	//
	// 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.
	//
	// +optional
	SearchDomains []string `json:"searchDomains,omitempty"`
}

type VirtualMachineNetworkStatus struct {

	// Interfaces describes the status of the VM's network interfaces.
	//
	// +optional
	// +listType=map
	// +listMapKey=name
	Interfaces []VirtualMachineNetworkInterfaceStatus `json:"interfaces,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.
	//
	// +optional
	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.
	//
	// +optional
	PrimaryIP6 string `json:"primaryIP6,omitempty"`

	VirtualMachineNetworkIPStackStatus `json:",inline"`
}

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.
	//
	// +optional
	Name string `json:"name,omitempty"`

	// APIVersion is the API version of the referenced object.
	//
	// +kubebuilder:default=vmoperator.vmware.com/v1alpha1
	// +optional
	APIVersion string `json:"apiVersion,omitempty"`

	// Kind is the kind of referenced object.
	//
	// +kubebuilder:default=VirtualMachine
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +optional
	// +kubebuilder:validation:Minimum=0
	TTLSecondsAfterFinished *int64 `json:"ttlSecondsAfterFinished,omitempty"`
}

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

	// TargetRef is the reference to the target of the publication request,
	// ex. item information and a ContentLibrary resource.
	//
	//
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +optional
	StartTime metav1.Time `json:"startTime,omitempty"`

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

	// LastAttemptTime represents the time when the latest request was sent.
	//
	// +optional
	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.
	//
	// +optional
	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
	//
	// +optional
	Ready bool `json:"ready,omitempty"`

	// Conditions is a list of the latest, available observations of the
	// request's current state.
	//
	// +optional
	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.
	//
	// +optional
	Item VirtualMachinePublishRequestTargetItem `json:"item,omitempty"`

	// Location contains information about the location to which to publish
	// the VM.
	//
	// +optional
	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".
	//
	// +optional
	Name string `json:"name,omitempty"`

	// Description is the description to assign to the published object.
	//
	// +optional
	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".
	//
	// +optional
	Name string `json:"name,omitempty"`

	// APIVersion is the API version of the referenced object.
	//
	// +kubebuilder:default=imageregistry.vmware.com/v1alpha1
	// +optional
	APIVersion string `json:"apiVersion,omitempty"`

	// Kind is the kind of referenced object.
	//
	// +kubebuilder:default=ContentLibrary
	// +optional
	Kind string `json:"kind,omitempty"`
}

type VirtualMachineReadinessGate struct {
	// ConditionType refers to a condition in the VM's condition list with
	// matching type.
	ConditionType string `json:"conditionType"`
}

type VirtualMachineReadinessProbeSpec struct {
	// TCPSocket specifies an action involving a TCP port.
	// +optional
	TCPSocket *TCPSocketAction `json:"tcpSocket,omitempty"`

	// GuestHeartbeat specifies an action involving the guest heartbeat status.
	// +optional
	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.
	//
	// +optional
	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.
	// +optional
	// +kubebuilder:validation:Minimum:=1
	// +kubebuilder:validation:Maximum:=60
	TimeoutSeconds int32 `json:"timeoutSeconds,omitempty"`

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

type VirtualMachineReservedSpec struct {
	// ResourcePolicyName describes the name of a
	// VirtualMachineSetResourcePolicy resource used to configure the VM's
	// resource policy.
	//
	// +optional
	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.
	// +optional
	Selector map[string]string `json:"selector,omitempty"`

	// Only applies to VirtualMachineService Type: LoadBalancer
	// LoadBalancer will get created with the IP specified in this field.
	// 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.
	// +optional
	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.
	// +optional
	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
	// +optional
	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.
	// +optional
	ExternalName string `json:"externalName,omitempty"`
}

type VirtualMachineServiceStatus struct {
	// LoadBalancer contains the current status of the load balancer,
	// if one is present.
	// +optional
	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 {
	// 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 ClusterVirtualMachineImage with the specified name. If no
	// such resource exists, the resolver then checks to see if there is a
	// VirtualMachineImage resource with the specified name in the same
	// Namespace as the VM being deployed.
	//
	// This field is optional in the cases where there exists a sensible
	// default value, such as when there is a single VirtualMachineImage
	// resource available in the same Namespace as the VM being deployed.
	//
	// +optional
	ImageName string `json:"imageName,omitempty"`

	// Class describes the name of the VirtualMachineClass resource used to
	// deploy this VM.
	//
	// This field is optional in the cases where there exists a sensible
	// default value, such as when there is a single VirtualMachineClass
	// resource available in the same Namespace as the VM being deployed.
	//
	// +optional
	ClassName string `json:"className,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.
	//
	// This field is optional in the cases where there exists a sensible
	// default value, such as when there is a single StorageClass
	// resource available in the same Namespace as the VM being deployed.
	//
	// +optional
	StorageClass string `json:"storageClass,omitempty"`

	// Bootstrap describes the desired state of the guest's bootstrap
	// configuration.
	//
	// If omitted, then the bootstrap method is determined based on the guest
	// identifier from the VirtualMachineImage. If the image's guest OS type is
	// Windows, then the Sysprep bootstrap method is used; if Linux, the
	// LinuxPrep method is used.
	//
	// Please note that defaulting to Sysprep for Windows images only works if
	// the image uses a volume license key, otherwise the image's product ID is
	// required.
	//
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +optional
	// +kubebuilder:default=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.
	//
	// +optional
	// +kubebuilder:default=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).
	//
	// +optional
	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.
	//
	// +optional
	// +kubebuilder:default=TrySoft
	RestartMode VirtualMachinePowerOpMode `json:"restartMode,omitempty"`

	// Volumes describes a list of volumes that can be mounted to the VM.
	//
	// +optional
	// +listType=map
	// +listMapKey=name
	Volumes []VirtualMachineVolume `json:"volumes,omitempty"`

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

	// ReadinessGates, if specified, will be evaluated to determine the VM's
	// readiness.
	//
	// A VM is ready when its readiness probe, if specified, is true AND all of
	// the conditions specified by the readiness gates have a status equal to
	// "True".
	//
	// +optional
	// +listType=map
	// +listMapKey=conditionType
	ReadinessGates []VirtualMachineReadinessGate `json:"readinessGates,omitempty"`

	// Advanced describes a set of optional, advanced VM configuration options.
	// +optional
	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.
	//
	// +optional
	Reserved VirtualMachineReservedSpec `json:"reserved,omitempty"`
}

type VirtualMachineStatus struct {
	// Image is a reference to the VirtualMachineImage resource used to deploy
	// this VM.
	//
	// +optional
	Image *common.LocalObjectRef `json:"image,omitempty"`

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

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

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

	// Conditions describes the observed conditions of the VirtualMachine.
	// +optional
	Conditions []metav1.Condition `json:"conditions,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.
	// +optional
	Network *VirtualMachineNetworkStatus `json:"network,omitempty"`

	// UniqueID describes a unique identifier that is provided by the underlying
	// infrastructure provider, such as vSphere.
	//
	// +optional
	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.
	//
	// +optional
	BiosUUID string `json:"biosUUID,omitempty"`

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

	// Volumes describes a list of current status information for each Volume
	// that is desired to be attached to the VM.
	// +optional
	// +listType=map
	// +listMapKey=name
	Volumes []VirtualMachineVolumeStatus `json:"volumes,omitempty"`

	// ChangeBlockTracking describes the CBT enablement status on the VM.
	//
	// +optional
	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.
	//
	// +optional
	Zone string `json:"zone,omitempty"`

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

type VirtualMachineTemplate struct {
	// Net describes the observed state of the VM's network configuration.
	// +optional
	Net NetworkStatus

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

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 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.
	//
	// +optional
	PersistentVolumeClaim *PersistentVolumeClaimVolumeSource `json:"persistentVolumeClaim,omitempty"`
}

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

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

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

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

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

type VirtualMachineWebConsoleRequestStatus struct {
	// 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"`
}