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.
	//
	// 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.
	//
	// +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 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.
	// +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
	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 *vmopv1a2cloudinit.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 *vmopv1a2common.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"`

	// 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.
	//
	// +optional
	// +kubebuilder:default:true
	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.
	//
	// +optional
	// +kubebuilder:default:true
	UseGlobalSearchDomainsAsDefault *bool `json:"useGlobalSearchDomainsAsDefault,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 *vmopv1a2sysprep.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 *vmopv1a2common.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 []vmopv1a2common.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"`

	// 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 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 *vmopv1a2common.LocalObjectRef `json:"providerRef,omitempty"`
}

type VirtualMachineImageStatus struct {

	// Name describes the display name of 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 user configurable OVF properties defined for this
	// image.
	//
	// +optional
	OVFProperties []OVFProperty `json:"ovfProperties,omitempty"`

	// VMwareSystemProperties describes the observed VMware system properties defined for
	// this image.
	//
	// +optional
	VMwareSystemProperties []vmopv1a2common.KeyValuePair `json:"vmwareSystemProperties,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"`

	// 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.
	// +optional
	ProviderItemID string `json:"providerItemID,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 VirtualMachineNetworkConfigDHCPOptionsStatus struct {
	// Enabled describes whether DHCP is enabled.
	// +omitempty
	Enabled bool `json:"enabled,omitempty"`
}

type VirtualMachineNetworkConfigDHCPStatus struct {

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

	// IP6 describes the configured state of the IP6 DHCP settings.
	//
	// +optional
	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".
	//
	// +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 VirtualMachineNetworkConfigInterfaceIPStatus struct {
	// DHCP describes the interface's configured DHCP options.
	//
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +optional
	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"`

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

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

type VirtualMachineNetworkConfigStatus struct {
	// Interfaces describes the configured state of the network interfaces.
	//
	// +optional
	Interfaces []VirtualMachineNetworkConfigInterfaceStatus `json:"interfaces,omitempty"`

	// DNS describes the configured state of client-side DNS.
	//
	// +optional
	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;'.
	//
	// +optional
	// +listType=map
	// +listMapKey=key
	Config []vmopv1a2common.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 []vmopv1a2common.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.
	//
	// 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.
	//
	// +kubebuilder:validation:Pattern="^[a-z0-9]{2,}$"
	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 *vmopv1a2common.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.
	//
	// +optional
	// +kubebuilder:validation:Pattern=^\w\w+$
	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.
	//
	// +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 IP6 addresses in the
	// Addresses field and the Gateway6 field.
	//
	// +optional
	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.
	//
	// +optional
	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.
	//
	// +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 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).
	//
	// +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.
	//
	// When using CloudInit and UseGlobalSearchDomainsAsDefault is either unset
	// or true, if search domains is not provided, the global search domains
	// will be used instead.
	//
	// +optional
	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.
	//
	// +optional
	Name string `json:"name,omitempty"`

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

	// 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 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.
	//
	// +optional
	// +kubebuilder:validation:Minimum=1
	Metric int32 `json:"metric,omitempty"`
}

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

type VirtualMachineNetworkSpec struct {
	// 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).
	//
	// When the bootstrap provider is Sysprep (except for RawSysprep) this is
	// used as the Computer Name.
	//
	// +optional
	HostName string `json:"hostName,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"`

	// 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).
	//
	// +optional
	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.
	//
	// +optional
	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 of the limit
	// built into vSphere.
	//
	// +optional
	// +listType=map
	// +listMapKey=name
	// +kubebuilder:validation:MaxItems=10
	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.
	//
	// +optional
	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.
	//
	// +optional
	Interfaces []VirtualMachineNetworkInterfaceStatus `json:"interfaces,omitempty"`

	// IPStacks describes information about the guest's configured IP networking
	// stacks.
	//
	// +optional
	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.
	//
	// +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"`
}

type VirtualMachinePowerOpMode string

type VirtualMachinePowerState string