v2alpha1

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

	// Spec is the specification of the ControlPlane resource.
	Spec ControlPlaneSpec `json:"spec,omitempty"`

	// Status is the status of the ControlPlane resource.
	//
	// +optional
	Status ControlPlaneStatus `json:"status,omitempty"`
}

type ControlPlaneController struct {
	// Name is the name of the controller.
	//
	// +required
	// +kubebuilder:validation:MinLength=1
	Name string `json:"name"`

	// State indicates whether the feature gate is enabled or disabled.
	//
	// +required
	// +kubebuilder:validation:Enum=enabled;disabled
	State ControllerState `json:"state"`
}

type ControlPlaneDataPlaneTarget struct {
	// Type indicates the type of the DataPlane target.
	//
	// +required
	// +kubebuilder:validation:Enum=ref;managedByOwner
	Type ControlPlaneDataPlaneTargetType `json:"type"`

	// Ref is the name of the DataPlane to configure.
	//
	// +optional
	Ref *ControlPlaneDataPlaneTargetRef `json:"ref,omitempty"`
}

type ControlPlaneDataPlaneTargetRef struct {
	// Ref is the name of the DataPlane to configure.
	//
	// +required
	Name string `json:"name"`
}

type ControlPlaneDataPlaneTargetType string

type ControlPlaneFeatureGate struct {
	// Name is the name of the feature gate.
	//
	// +required
	// +kubebuilder:validation:MinLength=1
	Name string `json:"name"`

	// State indicates whether the feature gate is enabled or disabled.
	//
	// +required
	// +kubebuilder:validation:Enum=enabled;disabled
	State FeatureGateState `json:"state"`
}

type ControlPlaneGatewayDiscovery struct {
	// ReadinessCheckInterval defines the interval at which the ControlPlane
	// checks the readiness of the DataPlanes it is responsible for.
	// If not specified, the default interval as defined by the operator will be used.
	//
	// +optional
	ReadinessCheckInterval *metav1.Duration `json:"readinessCheckInterval,omitempty"`

	// ReadinessCheckTimeout defines the timeout for the DataPlane readiness check.
	// If not specified, the default interval as defined by the operator will be used.
	//
	// +optional
	ReadinessCheckTimeout *metav1.Duration `json:"readinessCheckTimeout,omitempty"`
}

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

type ControlPlaneOptions struct {
	// IngressClass enables support for the Ingress resources and indicates
	// which Ingress resources this ControlPlane should be responsible for.
	//
	// If omitted, Ingress resources will not be supported by the ControlPlane.
	//
	// +optional
	IngressClass *string `json:"ingressClass,omitempty"`

	// WatchNamespaces indicates the namespaces to watch for resources.
	//
	// +optional
	// +kubebuilder:default={type: all}
	WatchNamespaces *operatorv1beta1.WatchNamespaces `json:"watchNamespaces,omitempty"`

	// FeatureGates is a list of feature gates that are enabled for this ControlPlane.
	//
	// +optional
	// +listType=map
	// +listMapKey=name
	// +kubebuilder:validation:MaxItems=32
	FeatureGates []ControlPlaneFeatureGate `json:"featureGates,omitempty"`

	// Controllers defines the controllers that are enabled for this ControlPlane.
	//
	// +optional
	// +listType=map
	// +listMapKey=name
	// +kubebuilder:validation:MaxItems=32
	Controllers []ControlPlaneController `json:"controllers,omitempty"`

	// GatewayDiscovery defines the configuration for the Gateway Discovery feature.
	//
	// +optional
	GatewayDiscovery *ControlPlaneGatewayDiscovery `json:"gatewayDiscovery,omitempty"`
}

type ControlPlaneSpec struct {
	// DataPlane designates the target data plane to configure.
	//
	// It can be:
	// - a name of a DataPlane resource that is managed by the operator,
	// - a DataPlane that is managed by the owner of the ControlPlane (e.g. a Gateway resource)
	//
	// +required
	DataPlane ControlPlaneDataPlaneTarget `json:"dataplane"`

	ControlPlaneOptions `json:",inline"`

	// Extensions provide additional or replacement features for the ControlPlane
	// resources to influence or enhance functionality.
	//
	// +optional
	// +kubebuilder:validation:MaxItems=2
	// +kubebuilder:validation:XValidation:message="Extension not allowed for ControlPlane",rule="self.all(e, (e.group == 'konnect.konghq.com' && e.kind == 'KonnectExtension') || (e.group == 'gateway-operator.konghq.com' && e.kind == 'DataPlaneMetricsExtension'))"
	Extensions []commonv1alpha1.ExtensionRef `json:"extensions,omitempty"`
}

type ControlPlaneStatus struct {
	// Conditions describe the current conditions of the Gateway.
	//
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=8
	// +kubebuilder:default={{type: "Scheduled", status: "Unknown", reason:"NotReconciled", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}
	Conditions []metav1.Condition `json:"conditions,omitempty"`

	// FeatureGates is a list of effective feature gates for this ControlPlane.
	//
	// +optional
	// +listType=map
	// +listMapKey=name
	// +kubebuilder:validation:MaxItems=32
	FeatureGates []ControlPlaneFeatureGate `json:"featureGates,omitempty"`

	// Controllers is a list of enabled and disabled controllers for this ControlPlane.
	//
	// +optional
	// +listType=map
	// +listMapKey=name
	// +kubebuilder:validation:MaxItems=32
	Controllers []ControlPlaneController `json:"controllers,omitempty"`
}

type ControllerState string

type FeatureGateState string

type GatewayConfigControlPlaneOptions struct {
	ControlPlaneOptions `json:",inline"`
}

type GatewayConfigDataPlaneNetworkOptions struct {
	// Services indicates the configuration of Kubernetes Services needed for
	// the topology of various forms of traffic (including ingress, etc.) to
	// and from the DataPlane.
	//
	// +optional
	Services *GatewayConfigDataPlaneServices `json:"services,omitempty"`
}

type GatewayConfigDataPlaneOptions struct {
	// +optional
	Deployment operatorv1beta1.DataPlaneDeploymentOptions `json:"deployment"`

	// +optional
	Network GatewayConfigDataPlaneNetworkOptions `json:"network"`

	// +optional
	Resources *GatewayConfigDataPlaneResources `json:"resources,omitempty"`

	// PluginsToInstall is a list of KongPluginInstallation resources that
	// will be installed and available in the Gateways (DataPlanes) that
	// use this GatewayConfig.
	//
	// +optional
	PluginsToInstall []NamespacedName `json:"pluginsToInstall,omitempty"`
}

type GatewayConfigDataPlaneResources struct {
	// PodDisruptionBudget is the configuration for the PodDisruptionBudget
	// that will be created for the DataPlane.
	//
	// +optional
	PodDisruptionBudget *PodDisruptionBudget `json:"podDisruptionBudget,omitempty"`
}

type GatewayConfigDataPlaneServices struct {
	// Ingress is the Kubernetes Service that will be used to expose ingress
	// traffic for the DataPlane. Here you can determine whether the DataPlane
	// will be exposed outside the cluster (e.g. using a LoadBalancer type
	// Services) or only internally (e.g. ClusterIP), and inject any additional
	// annotations you need on the service (for instance, if you need to
	// influence a cloud provider LoadBalancer configuration).
	//
	// +optional
	Ingress *GatewayConfigServiceOptions `json:"ingress,omitempty"`
}

type GatewayConfigServiceOptions struct {
	ServiceOptions `json:",inline"`
}

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

	// Spec defines the desired state of GatewayConfiguration.
	Spec GatewayConfigurationSpec `json:"spec,omitempty"`

	// Status defines the observed state of GatewayConfiguration.
	//
	// +optional
	Status GatewayConfigurationStatus `json:"status,omitempty"`
}

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

type GatewayConfigurationSpec struct {
	// DataPlaneOptions is the specification for configuration
	// overrides for DataPlane resources that will be created for the Gateway.
	//
	// +optional
	DataPlaneOptions *GatewayConfigDataPlaneOptions `json:"dataPlaneOptions,omitempty"`

	// ControlPlaneOptions is the specification for configuration
	// overrides for ControlPlane resources that will be managed as part of the Gateway.
	//
	// +optional
	ControlPlaneOptions *GatewayConfigControlPlaneOptions `json:"controlPlaneOptions,omitempty"`

	// Extensions provide additional or replacement features for the Gateway
	// resource to influence or enhance functionality.
	// NOTE: currently, there are only 2 extensions that can be attached
	// at the Gateway level (KonnectExtension, DataPlaneMetricsExtension),
	// so the amount of extensions is limited to 2.
	//
	// +optional
	// +kubebuilder:validation:MinItems=0
	// +kubebuilder:validation:MaxItems=2
	// +kubebuilder:validation:XValidation:message="Extension not allowed for GatewayConfiguration",rule="self.all(e, (e.group == 'konnect.konghq.com' && e.kind == 'KonnectExtension') || (e.group == 'gateway-operator.konghq.com' && e.kind == 'DataPlaneMetricsExtension'))"
	Extensions []commonv1alpha1.ExtensionRef `json:"extensions,omitempty"`
}

type GatewayConfigurationStatus struct {
	// Conditions describe the current conditions of the GatewayConfigurationStatus.
	//
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=8
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type NamespacedName struct {
	// Name is the name of the resource.
	//
	// +required
	Name string `json:"name"`

	// Namespace is the namespace of the resource.
	//
	// +optional
	Namespace string `json:"namespace"`
}

type PodDisruptionBudget struct {
	// Spec defines the specification of the PodDisruptionBudget.
	// Selector is managed by the controller and cannot be set by the user.
	Spec PodDisruptionBudgetSpec `json:"spec,omitempty"`
}

type PodDisruptionBudgetSpec struct {
	// An eviction is allowed if at least "minAvailable" pods selected by
	// "selector" will still be available after the eviction, i.e. even in the
	// absence of the evicted pod.  So for example you can prevent all voluntary
	// evictions by specifying "100%".
	//
	// +optional
	MinAvailable *intstr.IntOrString `json:"minAvailable,omitempty" protobuf:"bytes,1,opt,name=minAvailable"`

	// An eviction is allowed if at most "maxUnavailable" pods selected by
	// "selector" are unavailable after the eviction, i.e. even in absence of
	// the evicted pod. For example, one can prevent all voluntary evictions
	// by specifying 0. This is a mutually exclusive setting with "minAvailable".
	//
	// +optional
	MaxUnavailable *intstr.IntOrString `json:"maxUnavailable,omitempty" protobuf:"bytes,3,opt,name=maxUnavailable"`

	// UnhealthyPodEvictionPolicy defines the criteria for when unhealthy pods
	// should be considered for eviction. Current implementation considers healthy pods,
	// as pods that have status.conditions item with type="Ready",status="True".
	//
	// Valid policies are IfHealthyBudget and AlwaysAllow.
	// If no policy is specified, the default behavior will be used,
	// which corresponds to the IfHealthyBudget policy.
	//
	// IfHealthyBudget policy means that running pods (status.phase="Running"),
	// but not yet healthy can be evicted only if the guarded application is not
	// disrupted (status.currentHealthy is at least equal to status.desiredHealthy).
	// Healthy pods will be subject to the PDB for eviction.
	//
	// AlwaysAllow policy means that all running pods (status.phase="Running"),
	// but not yet healthy are considered disrupted and can be evicted regardless
	// of whether the criteria in a PDB is met. This means perspective running
	// pods of a disrupted application might not get a chance to become healthy.
	// Healthy pods will be subject to the PDB for eviction.
	//
	// Additional policies may be added in the future.
	// Clients making eviction decisions should disallow eviction of unhealthy pods
	// if they encounter an unrecognized policy in this field.
	//
	// This field is beta-level. The eviction API uses this field when
	// the feature gate PDBUnhealthyPodEvictionPolicy is enabled (enabled by default).
	//
	// +optional
	UnhealthyPodEvictionPolicy *policyv1.UnhealthyPodEvictionPolicyType `json:"unhealthyPodEvictionPolicy,omitempty" protobuf:"bytes,4,opt,name=unhealthyPodEvictionPolicy"`
}

type ServiceOptions struct {
	// Type determines how the Service is exposed.
	// Defaults to `LoadBalancer`.
	//
	// `ClusterIP` allocates a cluster-internal IP address for load-balancing
	// to endpoints.
	//
	// `NodePort` exposes the Service on each Node's IP at a static port (the NodePort).
	// To make the node port available, Kubernetes sets up a cluster IP address,
	// the same as if you had requested a Service of type: ClusterIP.
	//
	// `LoadBalancer` builds on NodePort and creates an external load-balancer
	// (if supported in the current cloud) which routes to the same endpoints
	// as the clusterIP.
	//
	// More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types
	//
	// +optional
	// +kubebuilder:default=LoadBalancer
	// +kubebuilder:validation:Enum=LoadBalancer;NodePort;ClusterIP
	Type corev1.ServiceType `json:"type,omitempty" protobuf:"bytes,4,opt,name=type,casttype=ServiceType"`

	// Name defines the name of the service.
	// If Name is empty, the controller will generate a service name from the owning object.
	//
	// +optional
	Name *string `json:"name,omitempty"`

	// Annotations is an unstructured key value map stored with a resource that may be
	// set by external tools to store and retrieve arbitrary metadata. They are not
	// queryable and should be preserved when modifying objects.
	//
	// More info: http://kubernetes.io/docs/user-guide/annotations
	//
	// +optional
	Annotations map[string]string `json:"annotations,omitempty" protobuf:"bytes,12,rep,name=annotations"`

	// ExternalTrafficPolicy describes how nodes distribute service traffic they
	// receive on one of the Service's "externally-facing" addresses (NodePorts,
	// ExternalIPs, and LoadBalancer IPs). If set to "Local", the proxy will configure
	// the service in a way that assumes that external load balancers will take care
	// of balancing the service traffic between nodes, and so each node will deliver
	// traffic only to the node-local endpoints of the service, without masquerading
	// the client source IP. (Traffic mistakenly sent to a node with no endpoints will
	// be dropped.) The default value, "Cluster", uses the standard behavior of
	// routing to all endpoints evenly (possibly modified by topology and other
	// features). Note that traffic sent to an External IP or LoadBalancer IP from
	// within the cluster will always get "Cluster" semantics, but clients sending to
	// a NodePort from within the cluster may need to take traffic policy into account
	// when picking a node.
	//
	// More info: https://kubernetes.io/docs/tasks/access-application-cluster/create-external-load-balancer/#preserving-the-client-source-ip
	//
	// +optional
	// +kubebuilder:validation:Enum=Cluster;Local
	ExternalTrafficPolicy corev1.ServiceExternalTrafficPolicy `json:"externalTrafficPolicy,omitempty"`
}