v1alpha2

type APIEndpoint struct {
	// host is the hostname on which the API server is serving.
	// +optional
	// +kubebuilder:validation:MinLength=1
	// +kubebuilder:validation:MaxLength=512
	Host string `json:"host,omitempty"`

	// port is the port on which the API server is serving.
	// +optional
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=65535
	Port int32 `json:"port,omitempty"`
}

type DiskSize struct {
	// disk is the name of the disk device that should be resized.
	// Example values are: ide[0-3], scsi[0-30], sata[0-5].
	// +kubebuilder:validation:MinLength=1
	// +required
	Disk string `json:"disk,omitempty"`

	// sizeGb defines the size in gigabytes.
	//
	// As Proxmox does not support shrinking, the size
	// must be bigger than the already configured size in the
	// template.
	//
	// +kubebuilder:validation:Minimum=5
	// +required
	SizeGB int32 `json:"sizeGb,omitempty"`
}

type IPAddressesSpec struct {
	// net is the proxmox network name these ipaddresses are attached to.
	// +kubebuilder:validation:MinLength=4
	// +kubebuilder:validation:Pattern=`^(net[0-9]+|default)$`
	// +required
	NetName string `json:"net,omitempty"`

	// ipv4 is the IPv4 address.
	// +listType=set
	// +optional
	IPv4 []string `json:"ipv4,omitempty"`

	// ipv6 is the IPv6 address.
	// +listType=set
	// +optional
	IPv6 []string `json:"ipv6,omitempty"`
}

type IPConfigSpec struct {
	// addresses is a list of IP addresses that can be assigned. This set of addresses can be non-contiguous.
	// +required
	// +listType=set
	Addresses []string `json:"addresses,omitempty"`

	// prefix is the network prefix to use.
	// +required
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=128
	Prefix int32 `json:"prefix,omitempty"`

	// gateway is the network gateway
	// +required
	// +kubebuilder:validation:MinLength=1
	Gateway string `json:"gateway,omitempty"`

	// metric is the route priority applied to the default gateway
	// +optional
	// +default=100
	// +kubebuilder:validation:Minimum=0
	Metric *int32 `json:"metric,omitempty"`
}

type InClusterZoneRef struct {
	// zone defines the deployment proxmox-zone.
	// +default="default"
	// +optional
	Zone Zone `json:"zone,omitempty"`

	// inClusterIPPoolRefV4 is the reference to the created in-cluster IP pool.
	// +optional
	InClusterIPPoolRefV4 *corev1.LocalObjectReference `json:"inClusterIPPoolRefV4,omitempty"`

	// inClusterIPPoolRefV6 is the reference to the created in-cluster IP pool.
	// +optional
	InClusterIPPoolRefV6 *corev1.LocalObjectReference `json:"inClusterIPPoolRefV6,omitempty"`
}

type InterfaceConfig struct {
	// ipPoolRef is a reference to an IPAM Pool resource, which exposes IPv4 addresses.
	// The network device will use an available IP address from the referenced pool.
	// This can be combined with `IPv6PoolRef` in order to enable dual stack.
	// +optional
	// +kubebuilder:validation:items:XValidation:rule="self.apiGroup == 'ipam.cluster.x-k8s.io'",message="ipPoolRef allows only IPAM apiGroup ipam.cluster.x-k8s.io"
	// +kubebuilder:validation:items:XValidation:rule="self.kind == 'InClusterIPPool' || self.kind == 'GlobalInClusterIPPool'",message="ipPoolRef allows either InClusterIPPool or GlobalInClusterIPPool"
	// +listType=atomic
	IPPoolRef []corev1.TypedLocalObjectReference `json:"ipPoolRef,omitempty"`

	// dnsServers contains information about nameservers to be used for this interface.
	// If this field is not set, it will use the default dns servers from the ProxmoxCluster.
	// +optional
	// +kubebuilder:validation:MinItems=1
	// +listType=set
	DNSServers []string `json:"dnsServers,omitempty"`

	// Routing is the common spec of routes and routing policies to all interfaces and VRFs.
	Routing `json:",inline"`

	// linkMtu is the network device Maximum Transmission Unit.
	// +optional
	// +kubebuilder:validation:XValidation:rule="self == 1 || (self >= 576 && self <= 65520)",message="invalid MTU value"
	LinkMTU MTU `json:"linkMtu,omitempty"`
}

type MTU *int32

type MetadataSettings struct {
	// providerIDInjection enables the injection of the `providerID` into the cloudinit metadata.
	// this will basically set the `provider-id` field in the metadata to `proxmox://<instanceID>`.
	// +required
	ProviderIDInjection *bool `json:"providerIDInjection,omitempty"`
}

type NetName string

type NetworkDevice struct {
	// bridge is the network bridge to attach to the machine.
	// +kubebuilder:validation:MinLength=1
	// +optional
	Bridge *string `json:"bridge,omitempty"`

	// defaultIPv4 attaches the ipv4 host network to this interface.
	// +optional
	DefaultIPv4 *bool `json:"defaultIPv4,omitempty"`

	// defaultIPv6 attaches the ipv6 host network to this interface.
	// +optional
	DefaultIPv6 *bool `json:"defaultIPv6,omitempty"`

	// model is the network device model.
	// Defaults to "virtio" when not specified.
	// +optional
	// +kubebuilder:validation:Enum=e1000;virtio;rtl8139;vmxnet3
	// +default="virtio"
	Model *string `json:"model,omitempty"`

	// mtu is the network device Maximum Transmission Unit.
	// When set to 1, virtio devices inherit the MTU value from the underlying bridge.
	// +optional
	// +kubebuilder:validation:XValidation:rule="self == 1 || (self >= 576 && self <= 65520)",message="invalid MTU value"
	MTU MTU `json:"mtu,omitempty"`

	// vlan is the network L2 VLAN.
	// +optional
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=4094
	VLAN *int32 `json:"vlan,omitempty"`

	// name is the network device name.
	// +default="net0"
	// +optional
	Name NetName `json:"name,omitempty"`

	// InterfaceConfig contains all configurables a network interface can have.
	// +optional
	InterfaceConfig `json:",inline"`
}

type NetworkSpec struct {
	// zone is the cluster deployment zone this machine will refer to.
	// +optional
	Zone Zone `json:"zone,omitempty"`

	// networkDevices is a list of network devices.
	// +required
	// +listType=map
	// +listMapKey=name
	//nolint:kubeapilinter
	NetworkDevices []NetworkDevice `json:"networkDevices,omitempty"`

	// VirtualNetworkDevices defines virtual network devices (e.g. bridges, vlans ...).
	VirtualNetworkDevices `json:",inline"`
}

type NetworkStatus struct {
	// connected is a flag that indicates whether this network is currently
	// connected to the VM.
	// +required
	Connected *bool `json:"connected,omitempty"`

	// ipAddrs is one or more IP addresses reported by vm-tools.
	// +listType=set
	// +optional
	IPAddrs []string `json:"ipAddrs,omitempty"`

	// macAddr is the MAC address of the network device.
	// +required
	// +kubebuilder:validation:Pattern=`^([0-9A-Fa-f]{2}[:]){5}([0-9A-Fa-f]{2})$`
	// +kubebuilder:validation:MinLength=17
	// +kubebuilder:validation:MaxLength=17
	MACAddr string `json:"macAddr,omitempty"`

	// networkName is the name of the network.
	// +optional
	NetworkName NetName `json:"networkName,omitempty"`
}

type NodeLocation struct {
	// machine is the reference to the ProxmoxMachine that the node is on.
	// +required
	Machine corev1.LocalObjectReference `json:"machine,omitempty"`

	// node is the Proxmox node.
	// +kubebuilder:validation:MinLength=1
	// +required
	Node string `json:"node,omitempty"`

	// zone is the zone the Machine is in.
	// +optional
	Zone Zone `json:"zone,omitempty"`
}

type NodeLocations struct {
	// controlPlane contains all deployed control plane nodes.
	// +optional
	// +listType=atomic
	ControlPlane []NodeLocation `json:"controlPlane,omitempty"`

	// workers contains all deployed worker nodes.
	// +optional
	// +listType=atomic
	Workers []NodeLocation `json:"workers,omitempty"`
}

type ProxmoxCluster struct {
	metav1.TypeMeta `json:",inline"`
	// metadata is the standard object metadata.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// spec is the Proxmox Cluster spec
	// +kubebuilder:validation:XValidation:rule="self.ipv4Config != null || self.ipv6Config != null",message="at least one ip config must be set, either ipv4Config or ipv6Config"
	// +required
	Spec ProxmoxClusterSpec `json:"spec,omitzero"`

	// status is the Proxmox Cluster status
	// +optional
	//nolint:kubeapilinter
	Status ProxmoxClusterStatus `json:"status,omitempty,omitzero"`
}

type ProxmoxClusterClassSpec struct {
	// machineType is the name of the template for ClusterClass.
	// +required
	// +kubebuilder:validation:MinLength=1
	MachineType string `json:"machineType,omitempty"`

	// proxmoxMachineSpec is the to be patched yaml object.
	ProxmoxMachineSpec `json:",inline"`
}

type ProxmoxClusterInitializationStatus struct {
	// provisioned is true when the infrastructure provider reports that the Cluster's infrastructure is fully provisioned.
	// NOTE: this field is part of the Cluster API contract, and it is used to orchestrate initial Cluster provisioning.
	// +optional
	Provisioned *bool `json:"provisioned,omitempty"`
}

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

type ProxmoxClusterSpec struct {
	// controlPlaneEndpoint represents the endpoint used to communicate with the control plane.
	// +optional
	ControlPlaneEndpoint APIEndpoint `json:"controlPlaneEndpoint,omitempty,omitzero"`

	// externalManagedControlPlane can be enabled to allow externally managed Control Planes to patch the
	// Proxmox cluster with the Load Balancer IP provided by Control Plane provider.
	// +optional
	// +default=false
	ExternalManagedControlPlane *bool `json:"externalManagedControlPlane,omitempty"`

	// allowedNodes specifies all Proxmox nodes which will be considered
	// for operations. This implies that VMs can be cloned on different nodes from
	// the node which holds the VM template.
	// +listType=set
	// +optional
	AllowedNodes []string `json:"allowedNodes,omitempty"`

	// schedulerHints allows to influence the decision on where a VM will be scheduled. For example by applying a multiplicator
	// to a node's resources, to allow for overprovisioning or to ensure a node will always have a safety buffer.
	// +optional
	SchedulerHints *SchedulerHints `json:"schedulerHints,omitempty"`

	// ipv4Config contains information about available IPv4 address pools and the gateway.
	// This can be combined with ipv6Config in order to enable dual stack.
	// Either IPv4Config or IPv6Config must be provided.
	// +optional
	// +kubebuilder:validation:XValidation:rule="self.addresses.size() > 0",message="IPv4Config addresses must be provided"
	IPv4Config *IPConfigSpec `json:"ipv4Config,omitempty,omitzero"`

	// ipv6Config contains information about available IPv6 address pools and the gateway.
	// This can be combined with ipv4Config in order to enable dual stack.
	// Either IPv4Config or IPv6Config must be provided.
	// +optional
	// +kubebuilder:validation:XValidation:rule="self.addresses.size() > 0",message="IPv6Config addresses must be provided"
	IPv6Config *IPConfigSpec `json:"ipv6Config,omitempty,omitzero"`

	// dnsServers contains information about nameservers used by the machines.
	// +required
	// +listType=set
	// +kubebuilder:validation:MinItems=1
	DNSServers []string `json:"dnsServers,omitempty"`

	// zoneConfig defines a IPAddress config per deployment zone.
	// +listType=map
	// +listMapKey=zone
	// +optional
	ZoneConfigs []ZoneConfigSpec `json:"zoneConfig,omitempty"`

	// credentialsRef is a reference to a Secret that contains the credentials to use for provisioning this cluster. If not
	// supplied then the credentials of the controller will be used.
	// if no namespace is provided, the namespace of the ProxmoxCluster will be used.
	// +optional
	CredentialsRef *corev1.SecretReference `json:"credentialsRef,omitempty"`
}

type ProxmoxClusterStatus struct {
	// conditions represents the observations of a ProxmoxCluster's current state.
	// Known condition types are Ready, ProxmoxAvailable and Paused.
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=32
	Conditions []metav1.Condition `json:"conditions,omitempty"`

	// initialization provides observations of the ProxmoxCluster initialization process.
	// NOTE: Fields in this struct are part of the Cluster API contract and are used to orchestrate initial Cluster provisioning.
	// +optional
	Initialization ProxmoxClusterInitializationStatus `json:"initialization,omitempty,omitzero"`

	// inClusterIPPoolRef is the reference to the created in-cluster IP pool.
	// +listType=atomic
	// +optional
	InClusterIPPoolRef []corev1.LocalObjectReference `json:"inClusterIPPoolRef,omitempty"`

	// inClusterZoneRef lists InClusterIPPools per proxmox-zone.
	// +optional
	// +listType=map
	// +listMapKey=zone
	//nolint:kubeapilinter
	InClusterZoneRef []InClusterZoneRef `json:"inClusterZoneRef,omitempty"`

	// nodeLocations keeps track of which nodes have been selected
	// for different machines.
	// +optional
	NodeLocations *NodeLocations `json:"nodeLocations,omitempty"`
}

type ProxmoxClusterTemplate struct {
	metav1.TypeMeta `json:",inline"`
	// metadata is the standard object metadata.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// spec is the Proxmox Cluster Template spec
	// +required
	Spec ProxmoxClusterTemplateSpec `json:"spec,omitzero"`
}

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

type ProxmoxClusterTemplateResource struct {
	// metadata is the standard object metadata.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	// +optional
	ObjectMeta clusterv1.ObjectMeta `json:"metadata,omitempty,omitzero"`

	// spec is the Proxmox Cluster spec
	// +required
	Spec ProxmoxClusterSpec `json:"spec,omitzero"`
}

type ProxmoxClusterTemplateSpec struct {
	// template is the Proxmox Cluster template
	// +required
	Template ProxmoxClusterTemplateResource `json:"template,omitzero"`
}

type ProxmoxMachine struct {
	metav1.TypeMeta `json:",inline"`
	// metadata is the standard object metadata.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// spec is the Proxmox machine spec.
	// +kubebuilder:validation:XValidation:rule="[has(self.sourceNode), has(self.templateSelector)].exists_one(c, c)",message="must define either a SourceNode with a TemplateID or a TemplateSelector"
	// +kubebuilder:validation:XValidation:rule="[has(self.templateID), has(self.templateSelector)].exists_one(c, c)",message="must define either a SourceNode with a TemplateID or a TemplateSelector"
	// +required
	Spec ProxmoxMachineSpec `json:"spec,omitzero"`

	// status is the status of the Proxmox machine.
	// +optional
	//nolint:kubeapilinter
	Status ProxmoxMachineStatus `json:"status,omitempty,omitzero"`
}

type ProxmoxMachineChecks struct {
	// skipCloudInitStatus skip checking CloudInit status which can be useful with specific Operating Systems like TalOS
	// +optional
	SkipCloudInitStatus *bool `json:"skipCloudInitStatus,omitempty"`
	// skipQemuGuestAgent skips checking QEMU Agent readiness which can be useful with specific Operating Systems like TalOS
	// +optional
	SkipQemuGuestAgent *bool `json:"skipQemuGuestAgent,omitempty"`
}

type ProxmoxMachineInitializationStatus struct {
	// provisioned is true when the infrastructure provider reports that the Machine's infrastructure is fully provisioned.
	// NOTE: this field is part of the Cluster API contract, and it is used to orchestrate initial Machine provisioning.
	// +optional
	Provisioned *bool `json:"provisioned,omitempty"`
}

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

type ProxmoxMachineSpec struct {
	VirtualMachineCloneSpec `json:",inline"`

	// providerID is the virtual machine BIOS UUID formatted as
	// proxmox://6c3fa683-bef9-4425-b413-eaa45a9d6191
	// +optional
	// +kubebuilder:validation:MinLength=46
	// +kubebuilder:validation:MaxLength=46
	// +kubebuilder:validation:Pattern=`^proxmox://[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$`
	ProviderID string `json:"providerID,omitempty"`

	// virtualMachineID is the Proxmox identifier for the ProxmoxMachine VM.
	// +optional
	VirtualMachineID *int64 `json:"virtualMachineID,omitempty"`

	// numSockets is the number of CPU sockets in a virtual machine.
	// Defaults to the property value in the template from which the virtual machine is cloned.
	// +kubebuilder:validation:Minimum=1
	// +optional
	NumSockets *int32 `json:"numSockets,omitempty"`

	// numCores is the number of cores per CPU socket in a virtual machine.
	// Defaults to the property value in the template from which the virtual machine is cloned.
	// +kubebuilder:validation:Minimum=1
	// +optional
	NumCores *int32 `json:"numCores,omitempty"`

	// memoryMiB is the size of a virtual machine's memory, in MiB.
	// Defaults to the property value in the template from which the virtual machine is cloned.
	// +kubebuilder:validation:MultipleOf=8
	// +kubebuilder:validation:Minimum=0
	// +optional
	MemoryMiB *int32 `json:"memoryMiB,omitempty"`

	// disks contains a set of disk configuration options,
	// which will be applied before the first startup.
	//
	// +optional
	Disks *Storage `json:"disks,omitempty"`

	// network is the network configuration for this machine's VM.
	// +required
	//nolint:kubeapilinter
	Network *NetworkSpec `json:"network,omitzero"`

	// vmIDRange is the range of VMIDs to use for VMs.
	// +optional
	// +kubebuilder:validation:XValidation:rule="self.end >= self.start",message="end should be greater than or equal to start"
	VMIDRange *VMIDRange `json:"vmIDRange,omitempty,omitzero"`

	// checks defines possible checks to skip.
	// +optional
	Checks *ProxmoxMachineChecks `json:"checks,omitempty"`

	// metadataSettings defines the metadata settings for this machine's VM.
	// +optional
	MetadataSettings *MetadataSettings `json:"metadataSettings,omitempty,omitzero"`

	// allowedNodes specifies all Proxmox nodes which will be considered
	// for operations. This implies that VMs can be cloned on different nodes from
	// the node which holds the VM template.
	//
	// This field is optional and should only be set if you want to restrict
	// the nodes where the VM can be cloned.
	// If not set, the ProxmoxCluster will be used to determine the nodes.
	// +optional
	// +listType=set
	AllowedNodes []string `json:"allowedNodes,omitempty"`

	// tags is a list of tags to be applied to the virtual machine.
	// +optional
	// +immutable
	// +listType=set
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:validation:items:Pattern=`^(?i)[a-z0-9_][a-z0-9_\-\+\.]*$`
	Tags []string `json:"tags,omitempty"`
}

type ProxmoxMachineStatus struct {
	// conditions defines current service state of the ProxmoxMachine.
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=32
	Conditions []metav1.Condition `json:"conditions,omitempty"`

	// initialization provides observations of the ProxmoxMachine initialization process.
	// NOTE: Fields in this struct are part of the Cluster API contract and are used to orchestrate initial Machine provisioning.
	// +optional
	Initialization ProxmoxMachineInitializationStatus `json:"initialization,omitempty,omitzero"`

	// addresses contains the Proxmox VM instance associated addresses.
	// +optional
	// +listType=atomic
	Addresses []clusterv1.MachineAddress `json:"addresses,omitempty"`

	// vmStatus is used to identify the virtual machine status.
	// +optional
	VMStatus *VirtualMachineState `json:"vmStatus,omitempty"`

	// bootstrapDataProvided whether the virtual machine has an injected bootstrap data.
	// +optional
	BootstrapDataProvided *bool `json:"bootstrapDataProvided,omitempty"`

	// ipAddresses are the IP addresses used to access the virtual machine.
	// +optional
	// +listType=map
	// +listMapKey=net
	IPAddresses []IPAddressesSpec `json:"ipAddresses,omitempty"`

	// network returns the network status for each of the machine's configured
	// network interfaces.
	// +optional
	// +listType=atomic
	Network []NetworkStatus `json:"network,omitempty"`

	// proxmoxNode is the name of the proxmox node, which was chosen for this
	// machine to be deployed on.
	// +optional
	ProxmoxNode *string `json:"proxmoxNode,omitempty"`

	// taskRef is a managed object reference to a Task related to the ProxmoxMachine.
	// This value is set automatically at runtime and should not be set or
	// modified by users.
	// +optional
	TaskRef *string `json:"taskRef,omitempty"`

	// retryAfter tracks the time we can retry queueing a task.
	// +optional
	RetryAfter *metav1.Time `json:"retryAfter,omitempty"`
}

type ProxmoxMachineTemplate struct {
	metav1.TypeMeta `json:",inline"`
	// metadata is the standard object metadata.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// spec is the machine template spec.
	// +required
	Spec ProxmoxMachineTemplateSpec `json:"spec,omitzero"`
}

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

type ProxmoxMachineTemplateResource struct {
	// metadata is the standard object metadata.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	// +optional
	ObjectMeta clusterv1.ObjectMeta `json:"metadata,omitempty,omitzero"`

	// spec is the Proxmox machine spec.
	// +required
	Spec ProxmoxMachineSpec `json:"spec,omitzero"`
}

type ProxmoxMachineTemplateSpec struct {
	// template is the Proxmox machine template resource.
	// +required
	Template ProxmoxMachineTemplateResource `json:"template,omitzero"`
}

type RouteSpec struct {
	// to is the subnet to be routed.
	// +optional
	To *string `json:"to,omitempty"`
	// via is the gateway to the subnet.
	// +optional
	Via *string `json:"via,omitempty"`
	// metric is the priority of the route in the routing table.
	// +kubebuilder:validation:Minimum=0
	// +optional
	Metric *int32 `json:"metric,omitempty"`
	// table is the routing table used for this route.
	// +optional
	Table *int32 `json:"table,omitempty"`
}

type Routing struct {
	// routes are the routes associated with this interface.
	// +optional
	// +kubebuilder:validation:MinItems=1
	// +listType=atomic
	//nolint:kubeapilinter
	Routes []RouteSpec `json:"routes,omitempty"`

	// routingPolicy is an interface-specific policy inserted into FIB (forwarding information base).
	// +optional
	// +kubebuilder:validation:MinItems=1
	// +listType=atomic
	//nolint:kubeapilinter
	RoutingPolicy []RoutingPolicySpec `json:"routingPolicy,omitempty"`
}

type RoutingPolicySpec struct {
	// to is the subnet of the target.
	// +optional
	To *string `json:"to,omitempty"`

	// from is the subnet of the source.
	// +optional
	From *string `json:"from,omitempty"`

	// table is the routing table ID.
	// +optional
	Table *int32 `json:"table,omitempty"`

	// priority is the position in the ip rule FIB table.
	// +kubebuilder:validation:Maximum=4294967295
	// +kubebuilder:validation:XValidation:message="Cowardly refusing to insert FIB rule matching kernel rules",rule="(self > 0 && self < 32765) || (self > 32766)"
	// +optional
	Priority *int64 `json:"priority,omitempty"`
}

type SchedulerHints struct {
	// memoryAdjustment allows to adjust a node's memory by a given percentage.
	// For example, setting it to 300 allows to allocate 300% of a host's memory for VMs,
	// and setting it to 95 limits memory allocation to 95% of a host's memory.
	// Setting it to 0 entirely disables scheduling memory constraints.
	// By default 100% of a node's memory will be used for allocation.
	// +kubebuilder:validation:Minimum=0
	// +optional
	MemoryAdjustment *int64 `json:"memoryAdjustment,omitempty"`
}

type Storage struct {
	// bootVolume defines the storage size for the boot volume.
	// This field is optional, and should only be set if you want
	// to change the size of the boot volume.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="Value is immutable"
	// +optional
	BootVolume *DiskSize `json:"bootVolume,omitempty,omitzero"`
}

type TargetFileStorageFormat string

type TemplateMatchPolicy string

type TemplateSelector struct {
	// matchTags specifies all tags to look for when looking up the VM template.
	// Passed tags must be an exact 1:1 match with the tags on the template you want to use.
	// If multiple VM templates with the same set of tags are found, provisioning will fail.
	//
	// +listType=set
	// +kubebuilder:validation:items:Pattern=`^(?i)[a-z0-9_][a-z0-9_\-\+\.]*$`
	// +kubebuilder:validation:MinItems=1
	// +required
	MatchTags []string `json:"matchTags,omitempty"`

	// matchPolicy controls how MatchTags are evaluated against template tags.
	// When not set, or set to "exact", the behaviour is identical to the previous implementation
	// and requires an exact 1:1 tag match. When set to "subset", the template's tags must contain
	// all MatchTags, but may include additional tags.
	//
	// +kubebuilder:validation:Enum=exact;uniqueSubset;bestSubset
	// +kubebuilder:default=exact
	// +optional
	MatchPolicy TemplateMatchPolicy `json:"matchPolicy,omitempty"`
}

type TemplateSource struct {
	// sourceNode is the initially selected proxmox node.
	// This node will be used to locate the template VM, which will
	// be used for cloning operations.
	//
	// Cloning will be performed according to the configuration.
	// Setting the `Target` field will tell Proxmox to clone the
	// VM on that target node.
	//
	// When Target is not set and the ProxmoxCluster contains
	// a set of `AllowedNodes`, the algorithm will instead evenly
	// distribute the VMs across the nodes from that list.
	//
	// If neither a `Target` nor `AllowedNodes` was set, the VM
	// will be cloned onto the same node as SourceNode.
	//
	// +kubebuilder:validation:MinLength=1
	// +optional
	SourceNode *string `json:"sourceNode,omitempty"`

	// templateID the vm_template vmid used for cloning a new VM.
	// +optional
	TemplateID *int32 `json:"templateID,omitempty"`

	// templateSelector defines MatchTags for looking up VM templates.
	// If a templateID is defined, templateSelector will be ignored.
	// +optional
	TemplateSelector *TemplateSelector `json:"templateSelector,omitempty,omitzero"`
}

type VMIDRange struct {
	// start is the start of the VMID range to use for VMs.
	// +kubebuilder:validation:Minimum=100
	// +kubebuilder:validation:ExclusiveMinimum=false
	// +kubebuilder:validation:Maximum=999999999
	// +kubebuilder:validation:ExclusiveMaximum=false
	// +required
	Start int64 `json:"start,omitempty"`

	// end is the end of the VMID range to use for VMs.
	// Only used if VMIDRangeStart is set.
	// +kubebuilder:validation:Minimum=100
	// +kubebuilder:validation:ExclusiveMinimum=false
	// +kubebuilder:validation:Maximum=999999999
	// +kubebuilder:validation:ExclusiveMaximum=false
	// +required
	End int64 `json:"end,omitempty"`
}

type VRFDevice struct {
	// interfaces is the list of proxmox network devices managed by this virtual device.
	// +optional
	// +listType=atomic
	Interfaces []NetName `json:"interfaces,omitempty"`

	// name is the virtual network device name.
	// Must be unique within the virtual machine.
	// +kubebuilder:validation:MinLength=3
	// +required
	Name string `json:"name,omitempty"`

	// table is the ID of the routing table used for the l3mdev vrf device.
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=4294967295
	// +kubebuilder:validation:XValidation:message="Cowardly refusing to insert l3mdev rules into kernel tables",rule="(self > 0 && self < 254) || (self > 255)"
	// +required
	Table int32 `json:"table,omitempty"`

	// Routing is the common spec of routes and routing policies to all interfaces and VRFs.
	Routing `json:",inline"`
}

type VirtualMachine struct {
	// node is the VM node.
	// +required
	// +kubebuilder:validation:MinLength=1
	Node string `json:"node,omitempty"`

	// name is the VM's name.
	// +required
	// +kubebuilder:validation:MinLength=1
	Name string `json:"name,omitempty"`

	// vmID is the VM's ID.
	// +required
	// +kubebuilder:validation:Minimum=100
	// +kubebuilder:validation:ExclusiveMinimum=false
	VMID int64 `json:"vmID,omitempty"`

	// state is the VM's state.
	// +required
	// +kubebuilder:validation:Enum=notfound;pending;ready
	State VirtualMachineState `json:"state,omitempty"`

	// network is the status of the VM's network devices.
	// +required
	// +listType=atomic
	Network []NetworkStatus `json:"network,omitempty"`
}

type VirtualMachineCloneSpec struct {
	TemplateSource `json:",inline"`

	// description for the new VM.
	// +optional
	Description *string `json:"description,omitempty"`

	// format for file storage. Only valid for full clone.
	// +kubebuilder:validation:Enum=raw;qcow2;vmdk
	// +optional
	Format *TargetFileStorageFormat `json:"format,omitempty"`

	// full Create a full copy of all disks.
	// This is always done when you clone a normal VM.
	// Defaults to true when not specified, creating a full clone by default.
	// +default=true
	// +optional
	Full *bool `json:"full,omitempty"`

	// pool Add the new VM to the specified pool.
	// +optional
	Pool *string `json:"pool,omitempty"`

	// snapName is the name of the snapshot.
	// +optional
	SnapName *string `json:"snapName,omitempty"`

	// storage for full clone.
	// +optional
	Storage *string `json:"storage,omitempty"`
}

type VirtualMachineState string

type VirtualNetworkDevices struct {
	// vrfs defines VRF Devices.
	// +optional
	// +listType=map
	// +listMapKey=name
	VRFs []VRFDevice `json:"vrfs,omitempty"`
}

type Zone *string

type ZoneConfigSpec struct {
	// zone is the name of your deployment zone.
	// +required
	Zone Zone `json:"zone,omitempty"`

	// ipv4Config contains information about available IPv4 address pools and the gateway.
	// This can be combined with ipv6Config in order to enable dual stack.
	// Either IPv4Config or IPv6Config must be provided.
	// +optional
	// +kubebuilder:validation:XValidation:rule="self.addresses.size() > 0",message="IPv4Config addresses must be provided"
	IPv4Config *IPConfigSpec `json:"ipv4Config,omitempty,omitzero"`

	// ipv6Config contains information about available IPv6 address pools and the gateway.
	// This can be combined with ipv4Config in order to enable dual stack.
	// Either IPv4Config or IPv6Config must be provided.
	// +optional
	// +kubebuilder:validation:XValidation:rule="self.addresses.size() > 0",message="IPv6Config addresses must be provided"
	IPv6Config *IPConfigSpec `json:"ipv6Config,omitempty,omitzero"`

	// dnsServers contains information about nameservers used by the machines in this zone.
	// +required
	// +listType=set
	// +kubebuilder:validation:MinItems=1
	DNSServers []string `json:"dnsServers,omitempty"`
}