v1alpha2

type APIEndpoint struct {
	// The hostname on which the API server is serving.
	Host string `json:"host"`

	// The port on which the API server is serving.
	Port int `json:"port"`
}

type AddonStatus struct {
	// Name of the add-on used.
	Name string `json:"name"`

	// Type of the add-on used
	Type AddonType `json:"type"`

	// Version of the distribution applied
	Version string `json:"version,omitempty"`

	// Conditions defines the current conditions of the add-on.
	// +optional
	Conditions clusterv1.Conditions `json:"conditions,omitempty"`
}

type AddonType string

type CNIConfiguration struct {
	// Name is the name of the CNI plugin to use.
	//
	// Supported values: "calico", "antrea".
	Name string `json:"name"`
}

type ContainerImage struct {
	// Repository is the container image repository used by this image. It MUST be a DNS-compatible name.
	// +optional
	Repository string `json:"repository,omitempty"`

	// Name is the container image name without the repository prefix.
	// It MUST be a valid URI path, MAY contain zero or more '/', and SHOULD NOT start or end with '/'.
	Name string `json:"name"`

	// Tag is the container image version tag. It is the suffix coming after ':' in a fully qualified image name.
	// +optional
	Tag string `json:"tag,omitempty"`
}

type Distribution struct {
	// Version specifies the fully-qualified desired Kubernetes distribution version of the Tanzu Kubernetes cluster. If the
	// cluster exists and is not of the specified version, it will be upgraded.
	//
	// Version is a semantic version string. The version may not be decreased. The major version may not be changed. If
	// the minor version is changed, it may only be incremented; skipping minor versions is not supported.
	//
	// The current observed version of the cluster is held by `status.version`.
	// DEPRECATED: use topology.controlPlane.tkr and topology.nodePools[*].tkr instead.
	// +optional
	Version string `json:"fullVersion"`

	// VersionHint provides the version webhook with guidance about the desired Kubernetes distribution version of the
	// Tanzu Kubernetes cluster. If a hint is provided without a full version, the most recent distribution matching the hint
	// will be selected.
	//
	// The version selected based on the hint will be stored in the spec as the full version. This ensures that the same
	// version is used if the cluster is scaled out in the future.
	//
	// VersionHint is a semantic prefix of a full version number. (E.g., v1.15.1 matches any distribution of v1.15.1,
	// including v1.15.1+vmware.1-tkg.1 or v1.15.1+vmware.2-tkg.1, but not v1.15.10+vmware.1-tkg.1.)
	//
	// A hint that does not match the full version is invalid and will be rejected.
	//
	// To upgrade a cluster to the most recent version that still matches the hint, leave the hint alone and remove the
	// fullVersion from the spec. This will cause the hint to be re-resolved.
	// DEPRECATED: use topology.controlPlane.tkr and topology.nodePools[*].tkr instead.
	// +optional
	VersionHint string `json:"version"`
}

type Network struct {
	// Services specify network settings for services.
	//
	// Defaults to 10.96.0.0/12.
	// +optional
	Services *NetworkRanges `json:"services,omitempty"`

	// Pods specify network settings for pods.
	//
	// When CNI is antrea, set Defaults to 192.168.0.0/16.
	// When CNI is antrea-nsx-routed, set Defaults to empty
	// +optional
	Pods *NetworkRanges `json:"pods,omitempty"`

	// ServiceDomain specifies service domain for Tanzu Kubernetes cluster.
	//
	// Defaults to a cluster.local.
	// +optional
	ServiceDomain string `json:"serviceDomain,omitempty"`

	// CNI is the Container Networking Interface plugin for the Tanzu Kubernetes cluster.
	//
	// Defaults to Calico.
	// +optional
	CNI *CNIConfiguration `json:"cni,omitempty"`

	// Proxy specifies HTTP(s) proxy configuration for Tanzu Kubernetes cluster.
	//
	// If omitted, no proxy will be configured in the system.
	// +optional
	Proxy *ProxyConfiguration `json:"proxy,omitempty"`

	// Trust specifies certificate configuration for the Tanzu Kubernetes Cluster.
	//
	// If omitted, no certificate will be configured in the system.
	// +optional
	Trust *TrustConfiguration `json:"trust,omitempty"`
}

type NetworkRanges struct {
	// CIDRBlocks specifies one or more ranges of IP addresses.
	//
	// Note: supplying multiple ranges many not be supported by all CNI plugins.
	// +optional
	CIDRBlocks []string `json:"cidrBlocks,omitempty"`
}

type NodePool struct {
	// Name is the name of the NodePool.
	Name string `json:"name"`

	// Labels are map of string keys and values that can be used to organize and categorize objects.
	// User-defined labels will be propagated to the created nodes.
	// +optional
	Labels map[string]string `json:"labels,omitempty"`

	// Taints specifies the taints the Node API object should be registered with.
	// User-defined taints will be propagated to the created nodes.
	// +optional
	Taints []corev1.Taint `json:"taints,omitempty"`

	TopologySettings `json:",inline"`
}

type ProxyConfiguration struct {
	// HttpProxy specifies a proxy URL to use for creating HTTP connections outside the cluster.
	// Example: http://<user>:<pwd>@<ip>:<port>
	//
	// +optional
	HttpProxy *string `json:"httpProxy,omitempty"` //nolint:revive,stylecheck

	// HttpsProxy specifies a proxy URL to use for creating HTTPS connections outside the cluster.
	// Example: http://<user>:<pwd>@<ip>:<port>
	//
	// +optional
	HttpsProxy *string `json:"httpsProxy,omitempty"` //nolint:revive,stylecheck

	// NoProxy specifies a list of destination domain names, domains, IP addresses or other network CIDRs to exclude proxying.
	// Example: [localhost, 127.0.0.1, 10.10.10.0/24]
	//
	// +optional
	NoProxy []string `json:"noProxy,omitempty"`
}

type Settings struct {
	// Network specifies network-related settings for the cluster.
	// +optional
	Network *Network `json:"network,omitempty"`

	// Storage specifies storage-related settings for the cluster.
	//
	// The storage used for node's disks is controlled by TopologySettings.
	// +optional
	Storage *Storage `json:"storage,omitempty"`
}

type Storage struct {
	// Classes is a list of storage classes from the supervisor namespace to expose within a cluster.
	//
	// If omitted, all storage classes from the supervisor namespace will be exposed within the cluster.
	// +optional
	Classes []string `json:"classes,omitempty"`
	// DefaultClass is the valid storage class name which is treated as the default storage class within a cluster.
	// If omitted, no default storage class is set
	// +optional
	DefaultClass string `json:"defaultClass,omitempty"`
}

type TKRReference struct {
	// Reference is a way to set the fixed link to the target object.
	// +optional
	Reference *corev1.ObjectReference `json:"reference,omitempty"`
}

type TLSCertificate struct {
	// Name specifies the name of the additional certificate, used in the filename
	// Example: CompanyInternalCA
	Name string `json:"name"`

	// Data specifies the contents of the additional certificate, encoded as a
	// base64 string. Specifically, this is the PEM Public Certificate data as
	// a base64 string..
	// Example: LS0tLS1C...LS0tCg== (where "..." is the middle section of the long base64 string)
	Data string `json:"data"`
}

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

	Spec   TanzuKubernetesClusterSpec   `json:"spec,omitempty"`
	Status TanzuKubernetesClusterStatus `json:"status,omitempty"`
}

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

type TanzuKubernetesClusterPhase string

type TanzuKubernetesClusterSpec struct {
	// Topology specifies the topology for the Tanzu Kubernetes cluster: the number, purpose, and organization of the nodes which
	// form the cluster and the resources allocated for each.
	Topology Topology `json:"topology"`

	// Distribution specifies the distribution for the Tanzu Kubernetes cluster: the software installed on the control plane and
	// worker nodes, including Kubernetes itself.
	// DEPRECATED: use topology.controlPlane.tkr and topology.nodePools[*].tkr instead.
	// +optional
	Distribution Distribution `json:"distribution,omitempty"`

	// Settings specifies settings for the Tanzu Kubernetes cluster: the way an instance of a distribution is configured,
	// including information about pod networking and storage.
	// +optional
	Settings *Settings `json:"settings,omitempty"`
}

type TanzuKubernetesClusterStatus struct {
	// APIEndpoints represents the endpoints to communicate with the control plane.
	// +optional
	APIEndpoints []APIEndpoint `json:"apiEndpoints,omitempty"`

	// Version holds the observed version of the Tanzu Kubernetes cluster. While an upgrade is in progress this value will be the
	// version of the cluster when the upgrade began.
	// +optional
	Version string `json:"version,omitempty"`

	// Addons groups the statuses of a Tanzu Kubernetes cluster's add-ons.
	// +optional
	Addons []AddonStatus `json:"addons,omitempty"`

	// Phase of this TanzuKubernetesCluster.
	// DEPRECATED: will be removed in v1alpha3
	// +optional
	Phase TanzuKubernetesClusterPhase `json:"phase,omitempty"`

	// Conditions defines current service state of the TanzuKubernetestCluster.
	// +optional
	Conditions clusterv1.Conditions `json:"conditions,omitempty"`

	// Total number of replicas in worker node pools.
	// +optional
	TotalWorkerReplicas int32 `json:"totalWorkerReplicas,omitempty"`
}

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

	Spec   TanzuKubernetesReleaseSpec   `json:"spec,omitempty"`
	Status TanzuKubernetesReleaseStatus `json:"status,omitempty"`
}

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

type TanzuKubernetesReleaseSpec struct {
	// Version is the fully qualified Semantic Versioning conformant version of the TanzuKubernetesRelease.
	// Version MUST be unique across all TanzuKubernetesRelease objects.
	Version string `json:"version"`

	// KubernetesVersion is the fully qualified Semantic Versioning conformant version of Kubernetes shipped by this TKR.
	// The same KubernetesVersion MAY be shipped by different TKRs.
	// +optional
	KubernetesVersion string `json:"kubernetesVersion,omitempty"`

	// Repository is the container image repository for Kubernetes core images, such as kube-apiserver, kube-proxy, etc.
	// It MUST be a DNS-compatible name.
	// +optional
	Repository string `json:"repository,omitempty"`

	// Images is the list of (other than Kubernetes core) essential container images shipped by this TKR (e.g. coredns, etcd).
	// +optional
	Images []ContainerImage `json:"images,omitempty"`

	// NodeImageRef refers to an object representing the image used to create TKC nodes (e.g. VirtualMachineImage).
	// +optional
	NodeImageRef *corev1.ObjectReference `json:"nodeImageRef,omitempty"`
}

type TanzuKubernetesReleaseStatus struct {
	Conditions []clusterv1.Condition `json:"conditions,omitempty"`
}

type Topology struct {
	// ControlPlane specifies the topology of the cluster's control plane, including the number of control plane nodes
	// and resources allocated for each. The control plane must have an odd number of nodes.
	ControlPlane TopologySettings `json:"controlPlane"`

	// NodePools specifies the topology of cluster's worker node pools, including the number of nodes and resources
	// allocated for each node.
	NodePools []NodePool `json:"nodePools"`
}

type TopologySettings struct {
	// Replicas is the number of nodes.
	// This is a pointer to distinguish between explicit zero and not specified, `nil`.
	// For control plane, defaults to 1 if `nil`.
	// For node pools, a value of `nil` indicates that the field will not be reconciled, allowing external services like
	// autoscalers to choose the number of nodes. By default, CAPI's `MachineDeployment` will pick 1.
	Replicas *int32 `json:"replicas,omitempty"`

	// VMClass is the name of the VirtualMachineClass, which describes the virtual hardware settings, to be used each node
	// in the pool. This controls the hardware available to the node (CPU and memory) as well as the requests and limits
	// on those resources. Run `kubectl describe virtualmachineclasses` to see which VM classes are available to use.
	VMClass string `json:"vmClass"`

	// StorageClass is the storage class to be used for storage of the disks which store the root filesystems of the
	// nodes. Run `kubectl describe ns` on your namespace to see which storage classes are available to use.
	StorageClass string `json:"storageClass"`

	// Volumes is the set of PVCs to be created and attached to each node.
	// +optional
	Volumes []Volume `json:"volumes,omitempty"`

	// TKR points to TanzuKubernetesRelease intended to be used by the node pool
	// (the control plane being special kind of a node pool).
	// +optional
	TKR TKRReference `json:"tkr,omitempty"`

	// NodeDrainTimeout is the total amount of time that the controller will
	// spend on draining a node. The default value is 0, meaning that the node
	// will be drained without any time limitations.
	// NOTE: NodeDrainTimeout is different from `kubectl drain --timeout`
	// +optional
	NodeDrainTimeout *metav1.Duration `json:"nodeDrainTimeout,omitempty"`
}

type TrustConfiguration struct {
	// AdditionalTrustedCAs specifies the additional trusted certificates (which
	// can be additional CAs or end certificates) to add to the cluster
	//
	// +optional
	AdditionalTrustedCAs []TLSCertificate `json:"additionalTrustedCAs,omitempty"`
}

type Volume struct {
	// Name is suffix used to name this PVC as: node.Name + "-" + Name
	Name string `json:"name"`
	// MountPath is the directory where the volume device is to be mounted
	MountPath string `json:"mountPath"`
	// Capacity is the PVC capacity
	Capacity corev1.ResourceList `json:"capacity"`
	// StorageClass is the storage class to be used for the disks.
	// Defaults to TopologySettings.StorageClass
	// +optional
	StorageClass string `json:"storageClass,omitempty"`
}