v1alpha1

type ClassReference struct {
	// API version of the referent.
	APIVersion string `json:"apiVersion,omitempty"`
	// Kind is the type of resource being referenced.
	Kind string `json:"kind,omitempty"`
	// Name is the name of resource being referenced.
	Name string `json:"name"`
}

type ClusterModuleSpec struct {
	// GroupName describes the name of the ClusterModule Group.
	GroupName string `json:"groupname"`
}

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

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 Condition struct {
	// Type of condition in CamelCase or in foo.example.com/CamelCase.
	// Many .condition.type values are consistent across resources like Available, but because arbitrary conditions
	// can be useful (see .node.status.conditions), the ability to disambiguate is important.
	// +required
	Type ConditionType `json:"type"`

	// Status of the condition, one of True, False, Unknown.
	// +required
	Status corev1.ConditionStatus `json:"status"`

	// Severity provides an explicit classification of Reason code, so the users or machines can immediately
	// understand the current situation and act accordingly.
	// The Severity field MUST be set only when Status=False.
	// +optional
	Severity ConditionSeverity `json:"severity,omitempty"`

	// Last time the condition transitioned from one status to another.
	// This should be when the underlying condition changed. If that is not known, then using the time when
	// the API field changed is acceptable.
	// +required
	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`

	// The reason for the condition's last transition in CamelCase.
	// The specific API may choose whether or not this field is considered a guaranteed API.
	// This field may not be empty.
	// +optional
	Reason string `json:"reason,omitempty"`

	// A human readable message indicating details about the transition.
	// This field may be empty.
	// +optional
	Message string `json:"message,omitempty"`
}

type ConditionSeverity string

type ConditionType string

type Conditions []Condition

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

	Spec   ContentLibraryProviderSpec   `json:"spec,omitempty"`
	Status ContentLibraryProviderStatus `json:"status,omitempty"`
}

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

type ContentLibraryProviderSpec struct {
	// UUID describes the UUID of a vSphere content library. It is the unique identifier for a
	// vSphere content library.
	UUID string `json:"uuid,omitempty"`
}

type ContentLibraryProviderStatus struct {
}

type ContentProviderReference struct {
	// API version of the referent.
	APIVersion string `json:"apiVersion,omitempty"`
	// Kind is the type of resource being referenced.
	Kind string `json:"kind"`
	// Name is the name of resource being referenced.
	Name string `json:"name"`
	// Namespace of the resource being referenced. If empty, cluster scoped resource is assumed.
	Namespace string `json:"namespace,omitempty"`
}

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

	Spec   ContentSourceSpec   `json:"spec,omitempty"`
	Status ContentSourceStatus `json:"status,omitempty"`
}

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

	// ContentSourceRef is a reference to a ContentSource object.
	ContentSourceRef ContentSourceReference `json:"contentSourceRef,omitempty"`
}

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

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

type ContentSourceReference struct {
	// API version of the referent.
	APIVersion string `json:"apiVersion,omitempty"`
	// Kind is the type of resource being referenced.
	Kind string `json:"kind,omitempty"`
	// Name is the name of resource being referenced.
	Name string `json:"name"`
}

type ContentSourceSpec struct {
	// ProviderRef is a reference to a content provider object that describes a provider.
	ProviderRef ContentProviderReference `json:"providerRef,omitempty"`
}

type ContentSourceStatus struct {
}

type DynamicDirectPathIODevice struct {
	VendorID int `json:"vendorID"`
	DeviceID int `json:"deviceID"`
	// +optional
	CustomLabel string `json:"customLabel,omitempty"`
}

type FolderSpec struct {
	// Name describes the name of the Folder
	// +optional
	Name string `json:"name,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 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 NetworkInterfaceProviderReference struct {
	// APIGroup is the group for the resource being referenced.
	APIGroup string `json:"apiGroup"`
	// Kind is the type of resource being referenced
	Kind string `json:"kind"`
	// Name is the name of resource being referenced
	Name string `json:"name"`
	// API version of the referent.
	APIVersion string `json:"apiVersion,omitempty"`
}

type NetworkInterfaceStatus struct {
	// Connected represents whether the network interface is connected or not.
	Connected bool `json:"connected"`

	// MAC address of the network adapter
	MacAddress string `json:"macAddress,omitempty"`

	// IpAddresses represents zero, one or more IP addresses assigned to the network interface in CIDR notation.
	// For eg, "192.0.2.1/16".
	IpAddresses []string `json:"ipAddresses,omitempty"` //nolint:revive,stylecheck
}

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 key of the ovf property.
	Key string `json:"key"`

	// Type describes the type of the ovf property.
	Type string `json:"type"`

	// Default describes the default value of the ovf key.
	// +optional
	Default *string `json:"default,omitempty"`

	// Description contains the value of the OVF property's optional
	// "Description" element.
	//
	// +optional
	Description string `json:"description,omitempty"`

	// Label contains the value of the OVF property's optional
	// "Label" element.
	//
	// +optional
	Label string `json:"label,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 Probe struct {
	// TCPSocket specifies an action involving a TCP port.
	//
	// Deprecated: The TCPSocket action requires network connectivity that is not supported in all environments.
	// This field will be removed in a later API version.
	// +optional
	TCPSocket *TCPSocketAction `json:"tcpSocket,omitempty"`

	// GuestHeartbeat specifies an action involving the guest heartbeat status.
	// +optional
	GuestHeartbeat *GuestHeartbeatAction `json:"guestHeartbeat,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 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 VirtualMachine.
	// 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 VirtualMachine IP.
	// +optional
	Host string `json:"host,omitempty"`
}

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

type VMStatusPhase string

type VirtualDevices struct {
	// +optional
	VGPUDevices []VGPUDevice `json:"vgpuDevices,omitempty" patchStrategy:"merge" patchMergeKey:"profileName"`
	// +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 VirtualMachineAdvancedOptions struct {
	// DefaultProvisioningOptions specifies the provisioning type to be used by default for VirtualMachine volumes exclusively
	// owned by this VirtualMachine. This does not apply to PersistentVolumeClaim volumes that are created and managed externally.
	DefaultVolumeProvisioningOptions *VirtualMachineVolumeProvisioningOptions `json:"defaultVolumeProvisioningOptions,omitempty"`

	// ChangeBlockTracking specifies the enablement of incremental backup support for this VirtualMachine, which can be utilized
	// by external backup systems such as VMware Data Recovery.
	ChangeBlockTracking *bool `json:"changeBlockTracking,omitempty"`
}

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

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

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

	// ClassReference is a reference to a VirtualMachineClass object
	ClassRef ClassReference `json:"classRef,omitempty"`
}

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

type VirtualMachineClassHardware struct {
	Cpus   int64             `json:"cpus,omitempty"`
	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 {
	Requests VirtualMachineResourceSpec `json:"requests,omitempty"`
	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.
	Hardware VirtualMachineClassHardware `json:"hardware,omitempty"`

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

	// Description describes the configuration of the VirtualMachineClass which is not related to virtual hardware
	// or infrastructure policy. This field is used to address remaining specs about this VirtualMachineClass.
	// +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 {
}

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 {
	// Version typically describes the version of the guest operating system.
	// +optional
	Version string `json:"version,omitempty"`

	// Type typically describes the type of the guest operating system.
	// +optional
	Type string `json:"type,omitempty"`
}

type VirtualMachineImageProductInfo struct {
	// Product typically describes the type of product contained in the image.
	// +optional
	Product string `json:"product,omitempty"`

	// Vendor typically describes the name of the vendor that is producing the image.
	// +optional
	Vendor string `json:"vendor,omitempty"`

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

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

type VirtualMachineImageSpec struct {
	// Type describes the type of the VirtualMachineImage. Currently, the only supported image is "OVF"
	Type string `json:"type"`

	// ImageSourceType describes the type of content source of the VirtualMachineImage.  The only Content Source
	// supported currently is the vSphere Content Library.
	// +optional
	ImageSourceType string `json:"imageSourceType,omitempty"`

	// ImageID is a unique identifier exposed by the provider of this VirtualMachineImage.
	ImageID string `json:"imageID"`

	// ProviderRef is a reference to a content provider object that describes a provider.
	ProviderRef ContentProviderReference `json:"providerRef"`

	// ProductInfo describes the attributes of the VirtualMachineImage relating to the product contained in the
	// image.
	// +optional
	ProductInfo VirtualMachineImageProductInfo `json:"productInfo,omitempty"`

	// OSInfo describes the attributes of the VirtualMachineImage relating to the Operating System contained in the
	// image.
	// +optional
	OSInfo VirtualMachineImageOSInfo `json:"osInfo,omitempty"`

	// OVFEnv describes the user configurable customization parameters of the VirtualMachineImage.
	// +optional
	OVFEnv map[string]OvfProperty `json:"ovfEnv,omitempty"`

	// HardwareVersion describes the virtual hardware version of the image
	// +optional
	HardwareVersion int32 `json:"hwVersion,omitempty"`
}

type VirtualMachineImageStatus struct {
	// Deprecated
	Uuid string `json:"uuid,omitempty"` //nolint:revive,stylecheck

	// Deprecated
	InternalId string `json:"internalId,omitempty"` //nolint:revive,stylecheck

	// Deprecated
	PowerState string `json:"powerState,omitempty"`

	// ImageName describes the display name of this image.
	// +optional
	ImageName string `json:"imageName,omitempty"`

	// ImageSupported indicates whether the VirtualMachineImage is supported by VMService.
	// A VirtualMachineImage is supported by VMService if the following conditions are true:
	// - VirtualMachineImageV1Alpha1CompatibleCondition
	// +optional
	ImageSupported *bool `json:"imageSupported,omitempty"`

	// Conditions describes the current condition information of the VirtualMachineImage object. e.g. if the OS type
	// is supported or image is supported by VMService
	// +optional
	Conditions []Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`

	// ContentLibraryRef is a reference to the source ContentLibrary/ClusterContentLibrary resource.
	//
	// Deprecated: This field is provider specific but the VirtualMachineImage types are intended to be provider generic.
	// This field does not exist in later API versions. Instead, the Spec.ProviderRef field should be used to look up the
	// provider. For images provided by a Content Library, the ProviderRef will point to either a ContentLibraryItem or
	// ClusterContentLibraryItem that contains a reference to the Content Library.
	// +optional
	ContentLibraryRef *corev1.TypedLocalObjectReference `json:"contentLibraryRef,omitempty"`

	// ContentVersion describes the observed content version of this VirtualMachineImage that was last successfully
	// synced with the vSphere content library item.
	// +optional
	ContentVersion string `json:"contentVersion,omitempty"`

	// Firmware describe the firmware type used by this VirtualMachineImage.
	// eg: bios, efi.
	// +optional
	Firmware string `json:"firmware,omitempty"`
}

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

type VirtualMachineMetadata struct {
	// ConfigMapName describes the name of the ConfigMap, in the same Namespace as the VirtualMachine, that should be
	// used for VirtualMachine metadata.  The contents of the Data field of the ConfigMap is used as the VM Metadata.
	// The format of the contents of the VM Metadata are not parsed or interpreted by the VirtualMachine controller.
	// Please note, this field and SecretName are mutually exclusive.
	// +optional
	ConfigMapName string `json:"configMapName,omitempty"`

	// SecretName describes the name of the Secret, in the same Namespace as the VirtualMachine, that should be used
	// for VirtualMachine metadata. The contents of the Data field of the Secret is used as the VM Metadata.
	// The format of the contents of the VM Metadata are not parsed or interpreted by the VirtualMachine controller.
	// Please note, this field and ConfigMapName are mutually exclusive.
	// +optional
	SecretName string `json:"secretName,omitempty"`

	// Transport describes the name of a supported VirtualMachineMetadata transport protocol.  Currently, the only supported
	// transport protocols are "ExtraConfig", "OvfEnv" and "CloudInit".
	Transport VirtualMachineMetadataTransport `json:"transport,omitempty"`
}

type VirtualMachineMetadataTransport string

type VirtualMachineNetworkInterface struct {
	// NetworkType describes the type of VirtualNetwork that is referenced by the NetworkName. Currently, the supported
	// NetworkTypes are "nsx-t", "nsx-t-subnet", "nsx-t-subnetset" and "vsphere-distributed".
	// +optional
	NetworkType string `json:"networkType,omitempty"`

	// NetworkName describes the name of an existing virtual network that this interface should be added to.
	// For "nsx-t" NetworkType, this is the name of a pre-existing NSX-T VirtualNetwork. If unspecified,
	// the default network for the namespace will be used. For "vsphere-distributed" NetworkType, the
	// NetworkName must be specified.
	// +optional
	NetworkName string `json:"networkName,omitempty"`

	// ProviderRef is reference to a network interface provider object that specifies the network interface configuration.
	// If unset, default configuration is assumed.
	// +optional
	ProviderRef *NetworkInterfaceProviderReference `json:"providerRef,omitempty"`

	// EthernetCardType describes an optional ethernet card that should be used by the VirtualNetworkInterface (vNIC)
	// associated with this network integration.  The default is "vmxnet3".
	// +optional
	EthernetCardType string `json:"ethernetCardType,omitempty"`
}

type VirtualMachinePort struct {
	Port     int             `json:"port"`
	Ip       string          `json:"ip"` //nolint:revive,stylecheck
	Name     string          `json:"name"`
	Protocol corev1.Protocol `json:"protocol"`
}

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 []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 display 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 VirtualMachineResourceSpec struct {
	Cpu    resource.Quantity `json:"cpu,omitempty"` //nolint:stylecheck,revive
	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.
	// Deprecated: This field was under-specified and its meaning varies across implementations.
	// Using it is non-portable and it may not support dual-stack.
	// Users are encouraged to use implementation-specific annotations when available.
	// +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         FolderSpec          `json:"folder,omitempty"`
	ClusterModules []ClusterModuleSpec `json:"clustermodules,omitempty"`
}

type VirtualMachineSetResourcePolicyStatus struct {
	ClusterModules []ClusterModuleStatus `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 VirtualMachineImage with the specified name. If no
	// such resource exists, the resolver then checks to see if there is a
	// ClusterVirtualMachineImage resource with the specified name in the same
	// Namespace as the VM being deployed.
	//
	// This field may also be used to specify the display name (vSphere name) of
	// a VirtualMachineImage or ClusterVirtualMachineImage resource. If the
	// display name unambiguously resolves to a distinct VM image (among all
	// existing VirtualMachineImages in the VM's namespace and all existing
	// ClusterVirtualMachineImages), then a mutation webhook updates this field
	// with the VM image resource name. If the display name resolves to multiple
	// or no VM images, then the mutation webhook denies the request and outputs
	// an error message accordingly.
	ImageName string `json:"imageName"`

	// ClassName describes the name of a VirtualMachineClass that is to be used as the overlaid resource configuration
	// of VirtualMachine.  A VirtualMachineClass is used to further customize the attributes of the VirtualMachine
	// instance.  See VirtualMachineClass for more description.
	ClassName string `json:"className"`

	// 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 hard.
	//
	// +optional
	// +kubebuilder:default=hard
	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 hard.
	//
	// +optional
	// +kubebuilder:default=hard
	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 hard.
	//
	// +optional
	// +kubebuilder:default=hard
	RestartMode VirtualMachinePowerOpMode `json:"restartMode,omitempty"`

	// Ports is currently unused and can be considered deprecated.
	// +optional
	Ports []VirtualMachinePort `json:"ports,omitempty"`

	// VmMetadata describes any optional metadata that should be passed to the Guest OS.
	// +optional
	VmMetadata *VirtualMachineMetadata `json:"vmMetadata,omitempty"` //nolint:revive,stylecheck

	// StorageClass describes the name of a StorageClass that should be used to configure storage-related attributes of the VirtualMachine
	// instance.
	// +optional
	StorageClass string `json:"storageClass,omitempty"`

	// NetworkInterfaces describes a list of VirtualMachineNetworkInterfaces to be configured on the VirtualMachine instance.
	// Each of these VirtualMachineNetworkInterfaces describes external network integration configurations that are to be
	// used by the VirtualMachine controller when integrating the VirtualMachine into one or more external networks.
	//
	// The maximum number of network interface allowed is 10 because of the limit built into vSphere.
	//
	// +optional
	// +kubebuilder:validation:MaxItems=10
	NetworkInterfaces []VirtualMachineNetworkInterface `json:"networkInterfaces,omitempty"`

	// ResourcePolicyName describes the name of a VirtualMachineSetResourcePolicy to be used when creating the
	// VirtualMachine instance.
	// +optional
	ResourcePolicyName string `json:"resourcePolicyName"`

	// Volumes describes the list of VirtualMachineVolumes that are desired to be attached to the VirtualMachine.  Each of
	// these volumes specifies a volume identity that the VirtualMachine controller will attempt to satisfy, potentially
	// with an external Volume Management service.
	// +optional
	// +patchMergeKey=name
	// +patchStrategy=merge
	Volumes []VirtualMachineVolume `json:"volumes,omitempty" patchStrategy:"merge" patchMergeKey:"name"`

	// ReadinessProbe describes a network probe that can be used to determine if the VirtualMachine is available and
	// responding to the probe.
	// +optional
	ReadinessProbe *Probe `json:"readinessProbe,omitempty"`

	// AdvancedOptions describes a set of optional, advanced options for configuring a VirtualMachine
	AdvancedOptions *VirtualMachineAdvancedOptions `json:"advancedOptions,omitempty"`

	// MinHardwareVersion specifies the desired minimum hardware version
	// for this VM.
	//
	// Usually the VM's hardware version is derived from:
	// 1. the VirtualMachineClass used to deploy the VM provided by the ClassName field
	// 2. the datacenter/cluster/host default hardware version
	// Setting this field will ensure that the hardware version of the VM
	// is at least set to the specified value. To enforce this, it will override
	// the value from the VirtualMachineClass.
	//
	// This field is never updated to reflect the derived hardware version.
	// Instead, VirtualMachineStatus.HardwareVersion surfaces
	// the observed hardware version.
	//
	// Please note, setting this field's value to N ensures a VM's hardware
	// version is equal to or greater than N. For example, if a VM's observed
	// hardware version is 10 and this field's value is 13, then the VM will be
	// upgraded to hardware version 13. However, if the observed hardware
	// version is 17 and this field's value is 13, no change will occur.
	//
	// Several features are hardware version dependent, for example:
	//
	// * NVMe Controllers                >= 14
	// * Dynamic Direct Path I/O devices >= 17
	//
	// Please refer to https://kb.vmware.com/s/article/1003746 for a list of VM
	// hardware versions.
	//
	// It is important to remember that a VM's hardware version may not be
	// downgraded and upgrading a VM deployed from an image based on an older
	// hardware version to a more recent one may result in unpredictable
	// behavior. In other words, please be careful when choosing to upgrade a
	// VM to a newer hardware version.
	//
	// +optional
	// +kubebuilder:validation:Minimum=13
	MinHardwareVersion int32 `json:"minHardwareVersion,omitempty"`
}

type VirtualMachineStatus struct {
	// Host describes the hostname or IP address of the infrastructure host that the VirtualMachine is executing on.
	// +optional
	Host string `json:"host,omitempty"`

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

	// Phase describes the current phase information of the VirtualMachine.
	// +optional
	Phase VMStatusPhase `json:"phase,omitempty"`

	// Conditions describes the current condition information of the VirtualMachine.
	// +optional
	Conditions []Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`

	// VmIp describes the Primary IP address assigned to the guest operating system, if known.
	// Multiple IPs can be available for the VirtualMachine. Refer to networkInterfaces in the VirtualMachine
	// status for additional IPs
	// +optional
	VmIp string `json:"vmIp,omitempty"` //nolint:revive,stylecheck

	// 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
	// VirtualMachine.
	// +optional
	Volumes []VirtualMachineVolumeStatus `json:"volumes,omitempty"`

	// ChangeBlockTracking describes the CBT enablement status on the VirtualMachine.
	// +optional
	ChangeBlockTracking *bool `json:"changeBlockTracking,omitempty"`

	// NetworkInterfaces describes a list of current status information for each network interface that is desired to
	// be attached to the VirtualMachine.
	// +optional
	NetworkInterfaces []NetworkInterfaceStatus `json:"networkInterfaces,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"`

	// HardwareVersion describes the VirtualMachine resource's observed
	// hardware version.
	//
	// Please refer to VirtualMachineSpec.MinHardwareVersion for more
	// information on the topic of a VM's hardware version.
	//
	// +optional
	HardwareVersion int32 `json:"hardwareVersion,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 specifies the name of the VirtualMachineVolume.  Each volume within the scope of a VirtualMachine must
	// have a unique name.
	Name string `json:"name"`

	// PersistentVolumeClaim represents a reference to a PersistentVolumeClaim
	// in the same namespace. The PersistentVolumeClaim must match one of the
	// following:
	//
	//   * A volume provisioned (either statically or dynamically) by the
	//     cluster's CSI provider.
	//
	//   * An instance volume with a lifecycle coupled to the VM.
	// +optional
	PersistentVolumeClaim *PersistentVolumeClaimVolumeSource `json:"persistentVolumeClaim,omitempty"`

	// VsphereVolume represents a reference to a VsphereVolumeSource in the same namespace. Only one of PersistentVolumeClaim or
	// VsphereVolume can be specified. This is enforced via a webhook
	// +optional
	VsphereVolume *VsphereVolumeSource `json:"vSphereVolume,omitempty"`
}

type VirtualMachineVolumeProvisioningOptions struct {
	// ThinProvisioned specifies whether to use thin provisioning for the VirtualMachineVolume.
	// This means a sparse (allocate on demand) format with additional space optimizations.
	ThinProvisioned *bool `json:"thinProvisioned,omitempty"`

	// EagerZeroed specifies whether to use eager zero provisioning for the VirtualMachineVolume.
	// An eager zeroed thick disk has all space allocated and wiped clean of any previous contents
	// on the physical media at creation time. Such disks may take longer time during creation
	// compared to other disk formats.
	// EagerZeroed is only applicable if ThinProvisioned is false. This is validated by the webhook.
	EagerZeroed *bool `json:"eagerZeroed,omitempty"`
}