v1alpha2

type AddressType = v1.AddressType

type AnnotationKey = v1.AnnotationKey

type AnnotationValue = v1.AnnotationValue

type BackendObjectReference = v1.BackendObjectReference

type BackendRef = v1.BackendRef

type CommonRouteSpec = v1.CommonRouteSpec

type Duration = v1.Duration

type GRPCRoute v1.GRPCRoute

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

type GatewayController = v1.GatewayController

type Group = v1.Group

type Hostname = v1.Hostname

type Kind = v1.Kind

type LocalObjectReference = v1.LocalObjectReference

type LocalPolicyTargetReference v1.LocalPolicyTargetReference

type LocalPolicyTargetReferenceWithSectionName v1.LocalPolicyTargetReferenceWithSectionName

type Namespace = v1.Namespace

type NamespacedPolicyTargetReference v1.NamespacedPolicyTargetReference

type ObjectName = v1.ObjectName

type ParentReference = v1.ParentReference

type PolicyAncestorStatus v1.PolicyAncestorStatus

type PolicyConditionReason v1.PolicyConditionReason

type PolicyConditionType v1.PolicyConditionType

type PolicyStatus v1.PolicyStatus

type PortNumber = v1.PortNumber

type PreciseHostname = v1.PreciseHostname

type ReferenceGrant v1beta1.ReferenceGrant

type ReferenceGrantFrom = v1beta1.ReferenceGrantFrom

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

type ReferenceGrantSpec = v1beta1.ReferenceGrantSpec

type ReferenceGrantTo = v1beta1.ReferenceGrantTo

type RouteConditionReason = v1.RouteConditionReason

type RouteConditionType = v1.RouteConditionType

type RouteParentStatus = v1.RouteParentStatus

type RouteStatus = v1.RouteStatus

type SecretObjectReference = v1.SecretObjectReference

type SectionName = v1.SectionName

type SessionPersistence = v1.SessionPersistence

type TCPRoute struct {
	metav1.TypeMeta `json:",inline"`
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Spec defines the desired state of TCPRoute.
	// +required
	Spec TCPRouteSpec `json:"spec"`

	// Status defines the current state of TCPRoute.
	// +optional
	Status TCPRouteStatus `json:"status,omitempty"`
}

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

type TCPRouteRule struct {
	// Name is the name of the route rule. This name MUST be unique within a Route if it is set.
	//
	// Support: Extended
	// +optional
	Name *SectionName `json:"name,omitempty"`

	// BackendRefs defines the backend(s) where matching requests should be
	// sent. If unspecified or invalid (refers to a nonexistent resource or a
	// Service with no endpoints), the underlying implementation MUST actively
	// reject connection attempts to this backend. Connection rejections must
	// respect weight; if an invalid backend is requested to have 80% of
	// connections, then 80% of connections must be rejected instead.
	//
	// Support: Core for Kubernetes Service
	//
	// Support: Extended for Kubernetes ServiceImport
	//
	// Support: Implementation-specific for any other resource
	//
	// Support for weight: Extended
	//
	// +required
	// +listType=atomic
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:validation:MaxItems=16
	BackendRefs []BackendRef `json:"backendRefs,omitempty"`
}

type TCPRouteSpec struct {
	CommonRouteSpec `json:",inline"`

	// Rules are a list of TCP matchers and actions.
	//
	// +required
	// +listType=atomic
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:validation:MaxItems=16
	// <gateway:experimental:validation:XValidation:message="Rule name must be unique within the route",rule="self.all(l1, !has(l1.name) || self.exists_one(l2, has(l2.name) && l1.name == l2.name))">
	Rules []TCPRouteRule `json:"rules"`
}

type TCPRouteStatus struct {
	RouteStatus `json:",inline"`
}

type TLSRoute struct {
	metav1.TypeMeta `json:",inline"`
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Spec defines the desired state of TLSRoute.
	// +required
	Spec TLSRouteSpec `json:"spec"`

	// Status defines the current state of TLSRoute.
	// +optional
	Status TLSRouteStatus `json:"status,omitempty"`
}

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

type TLSRouteRule struct {
	// Name is the name of the route rule. This name MUST be unique within a Route if it is set.
	//
	// Support: Extended
	// +optional
	Name *SectionName `json:"name,omitempty"`

	// BackendRefs defines the backend(s) where matching requests should be
	// sent. If unspecified or invalid (refers to a nonexistent resource or
	// a Service with no endpoints), the rule performs no forwarding; if no
	// filters are specified that would result in a response being sent, the
	// underlying implementation must actively reject request attempts to this
	// backend, by rejecting the connection or returning a 500 status code.
	// Request rejections must respect weight; if an invalid backend is
	// requested to have 80% of requests, then 80% of requests must be rejected
	// instead.
	//
	// Support: Core for Kubernetes Service
	//
	// Support: Extended for Kubernetes ServiceImport
	//
	// Support: Implementation-specific for any other resource
	//
	// Support for weight: Extended
	//
	// +required
	// +listType=atomic
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:validation:MaxItems=16
	BackendRefs []BackendRef `json:"backendRefs,omitempty"`
}

type TLSRouteSpec struct {
	CommonRouteSpec `json:",inline"`

	// Hostnames defines a set of SNI names that should match against the
	// SNI attribute of TLS ClientHello message in TLS handshake. This matches
	// the RFC 1123 definition of a hostname with 2 notable exceptions:
	//
	// 1. IPs are not allowed in SNI names per RFC 6066.
	// 2. A hostname may be prefixed with a wildcard label (`*.`). The wildcard
	//    label must appear by itself as the first label.
	//
	// If a hostname is specified by both the Listener and TLSRoute, there
	// must be at least one intersecting hostname for the TLSRoute to be
	// attached to the Listener. For example:
	//
	// * A Listener with `test.example.com` as the hostname matches TLSRoutes
	//   that have either not specified any hostnames, or have specified at
	//   least one of `test.example.com` or `*.example.com`.
	// * A Listener with `*.example.com` as the hostname matches TLSRoutes
	//   that have either not specified any hostnames or have specified at least
	//   one hostname that matches the Listener hostname. For example,
	//   `test.example.com` and `*.example.com` would both match. On the other
	//   hand, `example.com` and `test.example.net` would not match.
	//
	// If both the Listener and TLSRoute have specified hostnames, any
	// TLSRoute hostnames that do not match the Listener hostname MUST be
	// ignored. For example, if a Listener specified `*.example.com`, and the
	// TLSRoute specified `test.example.com` and `test.example.net`,
	// `test.example.net` must not be considered for a match.
	//
	// If both the Listener and TLSRoute have specified hostnames, and none
	// match with the criteria above, then the TLSRoute is not accepted. The
	// implementation must raise an 'Accepted' Condition with a status of
	// `False` in the corresponding RouteParentStatus.
	//
	// Support: Core
	//
	// +optional
	// +listType=atomic
	// +kubebuilder:validation:MaxItems=16
	Hostnames []Hostname `json:"hostnames,omitempty"`

	// Rules are a list of TLS matchers and actions.
	//
	// +required
	// +listType=atomic
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:validation:MaxItems=16
	// <gateway:experimental:validation:XValidation:message="Rule name must be unique within the route",rule="self.all(l1, !has(l1.name) || self.exists_one(l2, has(l2.name) && l1.name == l2.name))">
	Rules []TLSRouteRule `json:"rules"`
}

type TLSRouteStatus struct {
	RouteStatus `json:",inline"`
}

type UDPRoute struct {
	metav1.TypeMeta `json:",inline"`
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Spec defines the desired state of UDPRoute.
	// +required
	Spec UDPRouteSpec `json:"spec"`

	// Status defines the current state of UDPRoute.
	// +optional
	Status UDPRouteStatus `json:"status,omitempty"`
}

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

type UDPRouteRule struct {
	// Name is the name of the route rule. This name MUST be unique within a Route if it is set.
	//
	// Support: Extended
	// +optional
	Name *SectionName `json:"name,omitempty"`

	// BackendRefs defines the backend(s) where matching requests should be
	// sent. If unspecified or invalid (refers to a nonexistent resource or a
	// Service with no endpoints), the underlying implementation MUST actively
	// reject connection attempts to this backend. Packet drops must
	// respect weight; if an invalid backend is requested to have 80% of
	// the packets, then 80% of packets must be dropped instead.
	//
	// Support: Core for Kubernetes Service
	//
	// Support: Extended for Kubernetes ServiceImport
	//
	// Support: Implementation-specific for any other resource
	//
	// Support for weight: Extended
	//
	// +required
	// +listType=atomic
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:validation:MaxItems=16
	BackendRefs []BackendRef `json:"backendRefs,omitempty"`
}

type UDPRouteSpec struct {
	CommonRouteSpec `json:",inline"`

	// Rules are a list of UDP matchers and actions.
	//
	// +required
	// +listType=atomic
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:validation:MaxItems=16
	// <gateway:experimental:validation:XValidation:message="Rule name must be unique within the route",rule="self.all(l1, !has(l1.name) || self.exists_one(l2, has(l2.name) && l1.name == l2.name))">
	Rules []UDPRouteRule `json:"rules"`
}

type UDPRouteStatus struct {
	RouteStatus `json:",inline"`
}