v2beta1

type BlueGreenStrategy struct {
	// Promotion defines how the operator handles promotion of resources.
	//
	// +optional
	// +kubebuilder:default={"strategy":"BreakBeforePromotion"}
	Promotion *Promotion `json:"promotion,omitempty"`

	// Resources controls what happens to operator managed resources during or
	// after a rollout.
	//
	// +optional
	// +kubebuilder:default={"plan":{"deployment":"ScaleDownOnPromotionScaleUpOnRollout"}}
	Resources *RolloutResources `json:"resources,omitempty"`
}

type ConfigDumpState string

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 ControlPlaneCombinedServicesFromDifferentHTTPRoutesState string

type ControlPlaneConfigDump struct {
	// When State is enabled, Operator will dump the translated Kong configuration by it from a diagnostics server.
	//
	// +required
	// +kubebuilder:validation:Enum=enabled;disabled
	// +kubebuilder:default="disabled"
	State ConfigDumpState `json:"state"`

	// When DumpSensitive is enabled, the configuration will be dumped unchanged, including sensitive parts like private keys and credentials.
	// When DumpSensitive is disabled, the sensitive configuration parts like private keys and credentials are redacted.
	//
	// +required
	// +kubebuilder:validation:Enum=enabled;disabled
	// +kubebuilder:default="disabled"
	DumpSensitive ConfigDumpState `json:"dumpSensitive"`
}

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 ControlPlaneDataPlaneStatus struct {
	// Name is the name of the DataPlane.
	//
	// +required
	// +kubebuilder:validation:MinLength=1
	Name string `json:"name"`
}

type ControlPlaneDataPlaneSync struct {
	// ReverseSync sends configuration to DataPlane (Kong Gateway) even if
	// the configuration checksum has not changed since previous update.
	//
	// +optional
	// +kubebuilder:default=disabled
	ReverseSync *ControlPlaneReverseSyncState `json:"reverseSync,omitempty"`

	// Interval is the interval between two rounds of syncing Kong configuration with dataplanes.
	//
	// +optional
	Interval *metav1.Duration `json:"interval,omitempty"`

	// Timeout is the timeout of a single run of syncing Kong configuration with dataplanes.
	//
	// +optional
	Timeout *metav1.Duration `json:"timeout,omitempty"`
}

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 ControlPlaneDrainSupportState string

type ControlPlaneFallbackConfiguration struct {
	// UseLastValidConfig indicates whether the ControlPlane should use the last valid configuration
	// when the current configuration is invalid.
	//
	// +optional
	// +kubebuilder:default=enabled
	// +kubebuilder:validation:Enum=enabled;disabled
	UseLastValidConfig *ControlPlaneFallbackConfigurationState `json:"useLastValidConfig,omitempty"`
}

type ControlPlaneFallbackConfigurationState 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 ControlPlaneFilterForObjectType struct {
	// MatchLabels defines the labels that the object must match to get reconciled by the controller for the ControlPlane.
	// For example, if `secrets.matchLabels` is `{"label1":"val1","label2":"val2"}`,
	// only secrets with labels `label1=val1` and `label2=val2` are reconciled.
	//
	// +optional
	// +kubebuilder:validation:MaxProperties=8
	// +kubebuilder:validation:XValidation:message="Minimum length of key in matchLabels is 1",rule="self.all(key,key.size() >= 1)"
	// +kubebuilder:validation:XValidation:message="Maximum length of value in matchLabels is 63",rule="self.all(key,self[key].size() <= 63)"
	MatchLabels map[string]string `json:"matchLabels,omitempty"`
}

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 ControlPlaneK8sCache struct {
	// InitSyncDuration defines the initial delay to wait for Kubernetes object caches to be synced before the initial configuration.
	// If omitted, the default value (5s) is used.
	//
	// +optional
	InitSyncDuration *metav1.Duration `json:"initSyncDuration,omitempty"`
}

type ControlPlaneKonnectConsumersSyncState string

type ControlPlaneKonnectLicensing struct {
	// State indicates whether Konnect licensing is enabled.
	//
	// +optional
	// +kubebuilder:default=disabled
	// +kubebuilder:validation:Enum=enabled;disabled
	State *ControlPlaneKonnectLicensingState `json:"state,omitempty"`

	// InitialPollingPeriod is the initial polling period for license checks.
	//
	// +optional
	InitialPollingPeriod *metav1.Duration `json:"initialPollingPeriod,omitempty"`

	// PollingPeriod is the polling period for license checks.
	//
	// +optional
	PollingPeriod *metav1.Duration `json:"pollingPeriod,omitempty"`

	// StorageState indicates whether to store licenses fetched from Konnect
	// to Secrets locally to use them later when connection to Konnect is broken.
	// Only effective when State is set to enabled.
	//
	// +optional
	// +kubebuilder:default=enabled
	// +kubebuilder:validation:Enum=enabled;disabled
	StorageState *ControlPlaneKonnectLicensingState `json:"storageState,omitempty"`
}

type ControlPlaneKonnectLicensingState string

type ControlPlaneKonnectOptions struct {
	// ConsumersSync indicates whether consumer synchronization with Konnect is enabled.
	//
	// +optional
	// +kubebuilder:default=enabled
	// +kubebuilder:validation:Enum=enabled;disabled
	ConsumersSync *ControlPlaneKonnectConsumersSyncState `json:"consumersSync,omitempty"`

	// Licensing defines the configuration for Konnect licensing.
	//
	// +optional
	Licensing *ControlPlaneKonnectLicensing `json:"licensing,omitempty"`

	// NodeRefreshPeriod is the period for refreshing the node information in Konnect.
	//
	// +optional
	NodeRefreshPeriod *metav1.Duration `json:"nodeRefreshPeriod,omitempty"`

	// ConfigUploadPeriod is the period for uploading configuration to Konnect.
	//
	// +optional
	ConfigUploadPeriod *metav1.Duration `json:"configUploadPeriod,omitempty"`
}

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

type ControlPlaneObjectFilters struct {
	// Secrets defines the filters for watched secrets.
	//
	// +optional
	Secrets *ControlPlaneFilterForObjectType `json:"secrets,omitempty"`
	// ConfigMaps defines the filters for watched config maps.
	//
	// +optional
	ConfigMaps *ControlPlaneFilterForObjectType `json:"configMaps,omitempty"`
}

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 *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"`

	// Cache defines the configuration related to the kubernetes object caches.
	//
	// +optional
	Cache *ControlPlaneK8sCache `json:"cache,omitempty"`

	// DataPlaneSync defines the configuration for syncing Kong configuration to the DataPlane.
	//
	// +optional
	DataPlaneSync *ControlPlaneDataPlaneSync `json:"dataplaneSync,omitempty"`

	// Translation defines the configuration for translating Kong configuration.
	//
	// +optional
	Translation *ControlPlaneTranslationOptions `json:"translation,omitempty"`

	// ConfigDump defines the options for dumping generated Kong configuration from a diagnostics server.
	//
	// +optional
	ConfigDump *ControlPlaneConfigDump `json:"configDump,omitempty"`

	// ObjectFilters defines the filters to limit watched objects by the controllers.
	//
	// +optional
	ObjectFilters *ControlPlaneObjectFilters `json:"objectFilters,omitempty"`

	// Konnect defines the Konnect-related configuration options for the ControlPlane.
	//
	// +optional
	Konnect *ControlPlaneKonnectOptions `json:"konnect,omitempty"`
}

type ControlPlaneReverseSyncState string

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
	// +patchStrategy=merge
	// +patchMergeKey=type
	// +kubebuilder:validation:MaxItems=8
	// +kubebuilder:default={{type: "Provisioned", status: "Unknown", reason:"NotReconciled", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}
	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`

	// DataPlane describes the status of the DataPlane that the ControlPlane is
	// responsible for configuring.
	//
	// +optional
	DataPlane *ControlPlaneDataPlaneStatus `json:"dataPlane,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 ControlPlaneTranslationOptions struct {
	// CombinedServicesFromDifferentHTTPRoutes indicates whether the ControlPlane should
	// combine services from different HTTPRoutes into a single Kong DataPlane service.
	//
	// +optional
	// +kubebuilder:default=enabled
	// +kubebuilder:validation:Enum=enabled;disabled
	CombinedServicesFromDifferentHTTPRoutes *ControlPlaneCombinedServicesFromDifferentHTTPRoutesState `json:"combinedServicesFromDifferentHTTPRoutes,omitempty"`

	// FallbackConfiguration defines the fallback configuration options for the ControlPlane.
	//
	// +optional
	FallbackConfiguration *ControlPlaneFallbackConfiguration `json:"fallbackConfiguration,omitempty"`

	// DrainSupport defines the configuration for the ControlPlane to include
	// terminating endpoints in Kong upstreams with weight=0 for graceful connection draining.
	//
	// +optional
	// +kubebuilder:default=enabled
	// +kubebuilder:validation:Enum=enabled;disabled
	DrainSupport *ControlPlaneDrainSupportState `json:"drainSupport,omitempty"`
}

type ControllerState string

type DataPlaneDeploymentOptions struct {
	// Rollout describes a custom rollout strategy.
	//
	// +optional
	Rollout *Rollout `json:"rollout,omitempty"`

	DeploymentOptions `json:",inline"`
}

type DeploymentOptions struct {
	// Replicas describes the number of desired pods.
	// This is a pointer to distinguish between explicit zero and not specified.
	// This is effectively shorthand for setting a scaling minimum and maximum
	// to the same value. This field and the scaling field are mutually exclusive:
	// You can only configure one or the other.
	//
	// +optional
	Replicas *int32 `json:"replicas,omitempty"`

	// Scaling defines the scaling options for the deployment.
	//
	// +optional
	Scaling *Scaling `json:"scaling,omitempty"`

	// PodTemplateSpec defines PodTemplateSpec for Deployment's pods.
	// It's being applied on top of the generated Deployments using
	// [StrategicMergePatch](https://pkg.go.dev/k8s.io/apimachinery/pkg/util/strategicpatch#StrategicMergePatch).
	//
	// +optional
	PodTemplateSpec *corev1.PodTemplateSpec `json:"podTemplateSpec,omitempty"`
}

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 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 GatewayConfigurationListenerOptions struct {
	// Name is the name of the Listener.
	//
	// +required
	Name gatewayv1.SectionName `json:"name"`

	// The port on each node on which this service is exposed when type is
	// NodePort or LoadBalancer. Usually assigned by the system. If a value is
	// specified, in-range, and not in use it will be used, otherwise the
	// operation will fail. If not specified, a port will be allocated if this
	// Service requires one. If this field is specified when creating a
	// Service which does not need it, creation will fail. This field will be
	// wiped when updating a Service to no longer need it (e.g. changing type
	// from NodePort to ClusterIP).
	//
	// More info: https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport
	//
	// Can only be specified if type of the dataplane ingress service (specified in `spec.dataplaneOptions.network.services.ingress.type`)
	// is NodePort or LoadBalancer.
	//
	// +required
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=65535
	NodePort int32 `json:"nodePort"`
}

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"`

	// ListenerOptions is the specification for configuration bound to specific listeners in the Gateway.
	// It will override the default configuration of control plane or data plane for the specified listener.
	//
	// +optional
	// +kubebuilder:validation:MaxItems=64
	// +kubebuilder:validation:XValidation:message="Listener name must be unique within the Gateway",rule="self.all(l1, self.exists_one(l2, l1.name == l2.name))"
	// +kubebuilder:validation:XValidation:message="Nodeport must be unique within the Gateway if specified",rule="self.all(l1, !has(l1.nodePort) || self.exists_one(l2, l1.nodePort == l2.nodePort))"
	ListenersOptions []GatewayConfigurationListenerOptions `json:"listenersOptions,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
	// +patchStrategy=merge
	// +patchMergeKey=type
	// +kubebuilder:validation:MaxItems=8
	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
}

type GatewayConfigurationTargetKind string

type HorizontalScaling struct {
	// minReplicas is the lower limit for the number of replicas to which the autoscaler
	// can scale down.  It defaults to 1 pod.  minReplicas is allowed to be 0 if the
	// alpha feature gate HPAScaleToZero is enabled and at least one Object or External
	// metric is configured.  Scaling is active as long as at least one metric value is
	// available.
	// +optional
	MinReplicas *int32 `json:"minReplicas,omitempty" protobuf:"varint,2,opt,name=minReplicas"`

	// maxReplicas is the upper limit for the number of replicas to which the autoscaler can scale up.
	// It cannot be less that minReplicas.
	// +required
	MaxReplicas int32 `json:"maxReplicas" protobuf:"varint,3,opt,name=maxReplicas"`

	// metrics contains the specifications for which to use to calculate the
	// desired replica count (the maximum replica count across all metrics will
	// be used).  The desired replica count is calculated multiplying the
	// ratio between the target value and the current value by the current
	// number of pods.  Ergo, metrics used must decrease as the pod count is
	// increased, and vice-versa.  See the individual metric source types for
	// more information about how each type of metric must respond.
	// If not set, the default metric will be set to 80% average CPU utilization.
	// +listType=atomic
	// +optional
	Metrics []autoscalingv2.MetricSpec `json:"metrics,omitempty" protobuf:"bytes,4,rep,name=metrics"`

	// behavior configures the scaling behavior of the target
	// in both Up and Down directions (scaleUp and scaleDown fields respectively).
	// If not set, the default HPAScalingRules for scale up and scale down are used.
	// +optional
	Behavior *autoscalingv2.HorizontalPodAutoscalerBehavior `json:"behavior,omitempty" protobuf:"bytes,5,opt,name=behavior"`
}

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 Promotion struct {

	// Strategy indicates how you want the operator to handle the promotion of
	// the preview (green) resources (Deployments and Services) after all workflows
	// and tests succeed, OR if you even want it to break before performing
	// the promotion to allow manual inspection.
	//
	// +kubebuilder:validation:Enum=BreakBeforePromotion
	// +kubebuilder:default=BreakBeforePromotion
	// +optional
	Strategy *PromotionStrategy `json:"strategy,omitempty"`
}

type PromotionStrategy string

type Rollout struct {
	// Strategy contains the deployment strategy for rollout.
	//
	// +required
	Strategy RolloutStrategy `json:"strategy"`
}

type RolloutResourcePlan struct {

	// Deployment describes how the operator manages Deployments during and after a rollout.
	//
	// +kubebuilder:validation:Enum=ScaleDownOnPromotionScaleUpOnRollout
	// +kubebuilder:default=ScaleDownOnPromotionScaleUpOnRollout
	// +optional
	Deployment RolloutResourcePlanDeployment `json:"deployment,omitempty"`
}

type RolloutResourcePlanDeployment string

type RolloutResources struct {
	// Plan defines the resource plan for managing resources during and after a rollout.
	//
	// +optional
	// +kubebuilder:default={"deployment":"ScaleDownOnPromotionScaleUpOnRollout"}
	Plan RolloutResourcePlan `json:"plan,omitempty"`
}

type RolloutStrategy struct {
	// BlueGreen holds the options specific for Blue Green Deployments.
	//
	// +required
	BlueGreen BlueGreenStrategy `json:"blueGreen"`
}

type Scaling struct {
	// HorizontalScaling defines horizontal scaling options for the deployment.
	// +optional
	HorizontalScaling *HorizontalScaling `json:"horizontal,omitempty"`
}

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"`
}

type WatchNamespaces struct {
	// Type indicates the type of namespace watching to be done.
	// By default, all namespaces are watched.
	//
	// +required
	Type WatchNamespacesType `json:"type"`

	// List is a list of namespaces to watch for resources.
	// Only used when Type is set to List.
	//
	// +optional
	List []string `json:"list,omitempty"`
}

type WatchNamespacesType string