v1

type AffinityType string

type AlbConditionReason string

type AlbConditionType string

type AlbSpec struct {
	// Associations are subnet resource IDs the Application Gateway for Containers resource are associated with.
	Associations []string `json:"associations,omitempty"`
}

type AlbStatus struct {

	// +optional
	// Known condition types are:
	//
	// * "Accepted"
	// * "Ready"
	//
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=8
	// +kubebuilder:default={{type: "Accepted", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type ApplicationLoadBalancer struct {
	// Object's type metadata.
	metav1.TypeMeta `json:",inline"`

	// Object's metadata.
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Spec is the specifications for Application Gateway for Containers resource.
	Spec AlbSpec `json:"spec,omitempty"`

	// Status defines the current state of Application Gateway for Containers resource.
	//
	// +kubebuilder:default={conditions: {{type: "Accepted", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}}
	Status AlbStatus `json:"status,omitempty"`
}

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

type BackendLoadBalancingPolicy struct {
	// Object's type metadata.
	metav1.TypeMeta `json:",inline"`

	// Object's metadata.
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Spec is the BackendLoadBalancingPolicy specification.
	Spec BackendLoadBalancingPolicySpec `json:"spec,omitempty"`

	// Status defines the current state of BackendLoadBalancingPolicy.
	Status BackendLoadBalancingPolicyStatus `json:"status,omitempty"`
}

type BackendLoadBalancingPolicyConditionReason string

type BackendLoadBalancingPolicyConditionType string

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

type BackendLoadBalancingPolicyPort struct {
	// Port is the port to use for connection to the backend
	//
	// +kubebuilder:validation:Minimum=1
	Port int32 `json:"port,omitempty"`
}

type BackendLoadBalancingPolicySpec struct {
	// TargetRefs identifies a list of API objects to apply policy to.
	TargetRefs []TargetRefSpec `json:"targetRefs"`

	// CircuitBreaker defines the schema for configuring Circuit Breaking
	// +optional
	CircuitBreaker *CircuitBreakerConfig `json:"circuitBreaker,omitempty"`

	// LoadBalancing defines the schema for configuring Load Balancing options
	// +optional
	LoadBalancing *LoadBalancingConfig `json:"loadBalancing,omitempty"`
}

type BackendLoadBalancingPolicyStatus struct {
	Targets []BackendLoadBalancingPolicyTargetStatus `json:"targets"`
}

type BackendLoadBalancingPolicyTargetStatus struct {
	TargetRef CustomTargetRef `json:"targetRef"`

	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:validation:MaxItems=8
	// +kubebuilder:default={{type: "Accepted", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type BackendTLSPolicy struct {
	// Object's type metadata.
	metav1.TypeMeta `json:",inline"`

	// Object's metadata.
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Spec is the BackendTLSPolicy specification.
	Spec BackendTLSPolicySpec `json:"spec,omitempty"`

	// Status defines the current state of BackendTLSPolicy.
	//
	// +kubebuilder:default={conditions: {{type: "Accepted", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}}
	Status BackendTLSPolicyStatus `json:"status,omitempty"`
}

type BackendTLSPolicyConfig struct {
	CommonTLSPolicy `json:",inline"`

	// Sni is the server name to use for the TLS connection to the backend.
	//
	// +optional
	Sni string `json:"sni,omitempty"`

	// Ports specifies the list of ports where the policy is applied.
	Ports []BackendTLSPolicyPort `json:"ports,omitempty"`

	// ClientCertificateRef is the reference to the client certificate to
	// use for the TLS connection to the backend.
	//
	// +optional
	ClientCertificateRef *gatewayapi_v1.SecretObjectReference `json:"clientCertificateRef,omitempty"`
}

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

type BackendTLSPolicyPort struct {
	// Port is the port to use for the TLS connection to the backend
	//
	// +kubebuilder:validation:Minimum=1
	Port int `json:"port,omitempty"`
}

type BackendTLSPolicySpec struct {
	// TargetRef identifies an API object to apply policy to.
	TargetRef CustomTargetRef `json:"targetRef"`

	// Override defines policy configuration that should override policy
	// configuration attached below the targeted resource in the hierarchy.
	//
	// Note: Override is currently not supported and result in a validation error.
	// Support for Override will be added in a future release.
	//
	// +optional
	Override *BackendTLSPolicyConfig `json:"override,omitempty"`

	// Default defines default policy configuration for the targeted resource.
	//
	// +optional
	Default *BackendTLSPolicyConfig `json:"default,omitempty"`
}

type BackendTLSPolicyStatus struct {
	// Conditions describe the current conditions of the BackendTLSPolicy.
	//
	// Implementations should prefer to express BackendTLSPolicy conditions
	// using the `BackendTLSPolicyConditionType` and `BackendTLSPolicyConditionReason`
	// constants so that operators and tools can converge on a common
	// vocabulary to describe BackendTLSPolicy state.
	//
	// +optional
	// Known condition types are:
	//
	// * "Accepted"
	// * "ResolvedRefs"
	//
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=8
	// +kubebuilder:default={{type: "Accepted", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type CircuitBreakerConfig struct {
	// The maximum number of connections that will be made to the backend service.
	// Default is 1000000000 (disabled).
	//
	// +optional
	// +kubebuilder:default=1000000000
	// +kubebuilder:validation:Minimum=0
	MaxConnections uint32 `json:"maxConnections,omitempty"`

	// Maximum number of parallel requests that will be made to the backend service.
	// Default is 1000000000 (disabled).
	//
	// +optional
	// +kubebuilder:default=1000000000
	// +kubebuilder:validation:Minimum=0
	MaxRequests uint32 `json:"maxRequests,omitempty"`

	// Maximum number of pending requests that will be made to the backend service.
	// Default is 1000000000 (disabled).
	//
	// +optional
	// +kubebuilder:default=1000000000
	// +kubebuilder:validation:Minimum=0
	MaxPendingRequests uint32 `json:"maxPendingRequests,omitempty"`

	// The maximum number of parallel retries allowed to the backend service.
	// Default is 1000000000 (disabled).
	//
	// +optional
	// +kubebuilder:default=1000000000
	// +kubebuilder:validation:Minimum=0
	MaxRetries uint32 `json:"maxRetries,omitempty"`
}

type CommonTLSPolicy struct {
	// Verify provides the options to verify the peer certificate.
	//
	// +optional
	Verify *CommonTLSPolicyVerify `json:"verify,omitempty"`
}

type CommonTLSPolicyVerify struct {
	// CaCertificateRef is the CA certificate used to verify peer certificate.
	//
	// +kubebuilder:validation:Required
	CaCertificateRef *gatewayapi_v1.SecretObjectReference `json:"caCertificateRef,omitempty"`

	// SubjectAltName is the subject alternative name used to verify peer
	// certificate.
	//
	// +optional
	SubjectAltName string `json:"subjectAltName,omitempty"`
}

type CustomTargetRef struct {
	gatewayapi_v1alpha2.NamespacedPolicyTargetReference `json:",inline"`

	// SectionNames is the name of the section within the target resource. When
	// unspecified, this targetRef targets the entire resource. In the following
	// resources, SectionNames is interpreted as the following:
	//
	// * Gateway: Listener Name
	// * Service: Port Name
	//
	// If a SectionNames is specified, but doesn't exist on the targeted object,
	// the Policy fails to attach, and the policy implementation will record
	// a `ResolvedRefs` or similar Condition in the Policy's status.
	//
	//
	// +optional
	SectionNames []string `json:"sectionNames"`
}

type FrontendTLSPolicy struct {
	// Object's type metadata.
	metav1.TypeMeta `json:",inline"`

	// Object's metadata.
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Spec is the FrontendTLSPolicy specification.
	Spec FrontendTLSPolicySpec `json:"spec,omitempty"`

	// Status defines the current state of FrontendTLSPolicy.
	//
	// +kubebuilder:default={conditions: {{type: "Accepted", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}}
	Status FrontendTLSPolicyStatus `json:"status,omitempty"`
}

type FrontendTLSPolicyConfig struct {
	// Verify provides the options to verify the peer certificate.
	//
	// +optional
	Verify *MTLSPolicyVerify `json:"verify,omitempty"`

	// Type is the type of the policy.
	//
	// +optional
	// +kubebuilder:default={name: "2023-06", type: "predefined"}
	FrontendTLSPolicyType *PolicyType `json:"policyType"`
}

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

type FrontendTLSPolicySpec struct {
	// TargetRef identifies an API object to apply policy to.
	TargetRef CustomTargetRef `json:"targetRef"`

	// Default defines default policy configuration for the targeted resource.
	//
	// +optional
	Default *FrontendTLSPolicyConfig `json:"default,omitempty"`

	// Override defines policy configuration that should override policy
	// configuration attached below the targeted resource in the hierarchy.
	//
	// Note: Override is currently not supported and result in a validation error.
	// Support for Override will be added in a future release.
	//
	// +optional
	Override *FrontendTLSPolicyConfig `json:"override,omitempty"`
}

type FrontendTLSPolicyStatus struct {
	// Conditions describe the current conditions of the FrontendTLSPolicy.
	//
	// Implementations should prefer to express FrontendTLSPolicy conditions
	// using the `FrontendTLSPolicyConditionType` and `FrontendTLSPolicyConditionReason`
	// constants so that operators and tools can converge on a common
	// vocabulary to describe FrontendTLSPolicy state.
	//
	// +optional
	// Known condition types are:
	//
	// * "Accepted"
	//
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=8
	// +kubebuilder:default={{type: "Accepted", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type FrontendTLSPolicyType string

type FrontendTLSPolicyTypeName string

type GRPCSpecifiers struct {
	// Authority if present is used as the value of the Authority header in the health check.
	//
	// +optional
	Authority string `json:"authority,omitempty"`

	// Service allows the configuration of a Health check registered under a different service name.
	//
	// +optional
	Service string `json:"service,omitempty"`
}

type HTTPHeader struct {
	// Name is the name of the HTTP Header to be matched. Name matching MUST be
	// case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
	//
	// If multiple entries specify equivalent header names, the first entry with
	// an equivalent name MUST be considered for a match. Subsequent entries
	// with an equivalent header name MUST be ignored. Due to the
	// case-insensitivity of header names, "foo" and "Foo" are considered
	// equivalent.
	Name HTTPHeaderName `json:"name"`

	// Value is the value of HTTP Header to be matched.
	//
	// +kubebuilder:validation:MinLength=1
	// +kubebuilder:validation:MaxLength=4096
	Value string `json:"value"`
}

type HTTPHeaderName HeaderName

type HTTPMatch struct {
	// Body defines the HTTP body matchers to use for HealthCheck checks.
	//
	// +optional
	Body string `json:"body,omitempty"`

	// StatusCodes defines the HTTP status code matchers to use for HealthCheck checks.
	//
	// +optional
	StatusCodes []*StatusCodes `json:"statusCodes,omitempty"`
}

type HTTPPathModifier struct {
	// Type defines the type of path modifier. More types may be
	// added in a future release of the API.
	//
	// Values may be added to this enum, implementations
	// must ensure unknown values won't cause a crash.
	//
	// Unknown values here must result in the implementation setting the
	// Accepted Condition for the rule to be false
	//
	// +kubebuilder:validation:Enum=ReplaceFullPath;ReplacePrefixMatch
	Type HTTPPathModifierType `json:"type"`

	// ReplaceFullPath specifies the value with which to replace the full path
	// of a request during a rewrite or redirect.
	//
	// +kubebuilder:validation:MaxLength=1024
	// +optional
	ReplaceFullPath *string `json:"replaceFullPath,omitempty"`

	// ReplacePrefixMatch specifies the value with which to replace the prefix
	// match of a request during a rewrite or redirect. For example, a request
	// to "/foo/bar" with a prefix match of "/foo" and a ReplacePrefixMatch
	// of "/xyz" would be modified to "/xyz/bar".
	//
	// This matches the behavior of the PathPrefix match type. This
	// matches full path elements. A path element refers to the list of labels
	// in the path split by the `/` separator. When specified, a trailing `/` is
	// ignored. For example, the paths `/abc`, `/abc/`, and `/abc/def` would all
	// match the prefix `/abc`, but the path `/abcd` wouldn't.
	//
	// ReplacePrefixMatch is only compatible with a `PathPrefix` HTTPRouteMatch.
	// Using any other HTTPRouteMatch type on the same HTTPRouteRule results in
	// the implementation setting the Accepted Condition for the Route to `status: False`.
	//
	// Request Path | Prefix Match | Replace Prefix | Modified Path
	// |------------|--------------|----------------|----------
	// /foo/bar     | /foo         | /xyz           | /xyz/bar
	// /foo/bar     | /foo         | /xyz/          | /xyz/bar
	// /foo/bar     | /foo/        | /xyz           | /xyz/bar
	// /foo/bar     | /foo/        | /xyz/          | /xyz/bar
	// /foo         | /foo         | /xyz           | /xyz
	// /foo/        | /foo         | /xyz           | /xyz/
	// /foo/bar     | /foo         | <empty string> | /bar
	// /foo/        | /foo         | <empty string> | /
	// /foo         | /foo         | <empty string> | /
	// /foo/        | /foo         | /              | /
	// /foo         | /foo         | /              | /
	//
	// +kubebuilder:validation:MaxLength=1024
	// +optional
	ReplacePrefixMatch *string `json:"replacePrefixMatch,omitempty"`
}

type HTTPPathModifierType string

type HTTPSpecifiers struct {
	// Host is the host header value to use for HealthCheck checks.
	//
	// +optional
	Host string `json:"host,omitempty"`

	// Path is the path to use for HealthCheck checks.
	//
	// +optional
	Path string `json:"path,omitempty"`

	// Match defines the HTTP matchers to use for HealthCheck checks.
	//
	// +optional
	Match *HTTPMatch `json:"match,omitempty"`
}

type HeaderFilter struct {
	// Set overwrites the request with the given header (name, value)
	// before the action.
	//
	// Input:
	//   GET /foo HTTP/1.1
	//   my-header: foo
	//
	// Config:
	//   set:
	//   - name: "my-header"
	//     value: "bar"
	//
	// Output:
	//   GET /foo HTTP/1.1
	//   my-header: bar
	//
	// +optional
	// +listType=map
	// +listMapKey=name
	// +kubebuilder:validation:MaxItems=16
	Set []HTTPHeader `json:"set,omitempty"`

	// Add adds the given header(s) (name, value) to the request
	// before the action. It appends to any existing values associated
	// with the header name.
	//
	// Input:
	//   GET /foo HTTP/1.1
	//   my-header: foo
	//
	// Config:
	//   add:
	//   - name: "my-header"
	//     value: "bar,baz"
	//
	// Output:
	//   GET /foo HTTP/1.1
	//   my-header: foo,bar,baz
	//
	// +optional
	// +listType=map
	// +listMapKey=name
	// +kubebuilder:validation:MaxItems=16
	Add []HTTPHeader `json:"add,omitempty"`

	// Remove the given header(s) from the HTTP request before the action. The
	// value of Remove is a list of HTTP header names. Header names
	// are case-insensitive (see
	// https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
	//
	// Input:
	//   GET /foo HTTP/1.1
	//   my-header1: foo
	//   my-header2: bar
	//   my-header3: baz
	//
	// Config:
	//   remove: ["my-header1", "my-header3"]
	//
	// Output:
	//   GET /foo HTTP/1.1
	//   my-header2: bar
	//
	// +optional
	// +kubebuilder:validation:MaxItems=16
	Remove []string `json:"remove,omitempty"`
}

type HeaderName string

type HealthCheckPolicy struct {
	// Object's type metadata.
	metav1.TypeMeta `json:",inline"`

	// Object's metadata.
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Spec is the HealthCheckPolicy specification.
	Spec HealthCheckPolicySpec `json:"spec,omitempty"`

	// Status defines the current state of HealthCheckPolicy.
	//
	// +kubebuilder:default={conditions: {{type: "Accepted", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}}
	Status HealthCheckPolicyStatus `json:"status,omitempty"`
}

type HealthCheckPolicyConditionReason string

type HealthCheckPolicyConditionType string

type HealthCheckPolicyConfig struct {
	// Interval is the number of seconds between HealthCheck checks.
	//
	// +optional
	Interval metav1.Duration `json:"interval,omitempty"`

	// Timeout is the number of seconds after which the HealthCheck check is
	// considered failed.
	//
	// +optional
	Timeout metav1.Duration `json:"timeout,omitempty"`

	// Port is the port to use for HealthCheck checks.
	//
	// +optional
	Port int32 `json:"port,omitempty"`

	// UnhealthyThreshold is the number of consecutive failed HealthCheck checks.
	//
	// +optional
	UnhealthyThreshold int32 `json:"unhealthyThreshold,omitempty"`

	// HealthyThreshold is the number of consecutive successful HealthCheck checks.
	//
	// +optional
	HealthyThreshold int32 `json:"healthyThreshold,omitempty"`

	// UseTLS indicates whether health check should enforce TLS.
	// By default, health check will use the same protocol as the
	// service if the same port is used for health check. If the port
	// is different, health check will be plaintext.
	//
	// +optional
	UseTLS bool `json:"useTLS,omitempty"`

	// HTTP defines the HTTP constraint specification for the HealthCheck of a
	// target resource.
	//
	// +optional
	HTTP *HTTPSpecifiers `json:"http,omitempty"`

	// GRPC configures a gRPC v1 HealthCheck (https://github.com/grpc/grpc-proto/blob/master/grpc/health/v1/health.proto)
	// against the target resource.
	GRPC *GRPCSpecifiers `json:"grpc,omitempty"`
}

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

type HealthCheckPolicySpec struct {
	// TargetRef identifies an API object to apply policy to.
	TargetRef CustomTargetRef `json:"targetRef"`

	// Override defines policy configuration that should override policy
	// configuration attached below the targeted resource in the hierarchy.
	//
	// Note: Override is currently not supported and will result in a validation error.
	// Support for Override will be added in a future release.
	//
	// +optional
	Override *HealthCheckPolicyConfig `json:"override,omitempty"`

	// Default defines default policy configuration for the targeted resource.
	//
	// +optional
	Default *HealthCheckPolicyConfig `json:"default,omitempty"`
}

type HealthCheckPolicyStatus struct {
	// Conditions describe the current conditions of the HealthCheckPolicy.
	//
	// Implementations should prefer to express HealthCheckPolicy conditions
	// using the `HealthCheckPolicyConditionType` and `HealthCheckPolicyConditionReason`
	// constants so that operators and tools can converge on a common
	// vocabulary to describe HealthCheckPolicy state.
	//
	// +optional
	// Known condition types are:
	//
	// * "Accepted"
	//
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=8
	// +kubebuilder:default={{type: "Accepted", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type IngressBackendPort struct {
	// Port indicates the port  on the backend service
	// +optional
	Port *int32 `json:"port"`

	// Name must refer to a name on a port on the backend service
	// +optional
	Name *string `json:"name"`

	// Protocol should be one of "HTTP", "HTTPS"
	// +kubebuilder:validation:Enum=HTTP;HTTPS
	Protocol Protocol `json:"protocol"`
}

type IngressBackendSettingStatus struct {
	// Service identifies the BackendSetting this status describes
	Service string `json:"service"`

	// Errors are a list of errors relating to this setting
	// +optional
	Errors []string `json:"validationErrors"`

	// Valid indicates that there are no validation errors present on this BackendSetting
	Valid bool `json:"valid"`
}

type IngressBackendSettings struct {
	// Service is the name of a backend service that this configuration applies to
	Service string `json:"service"`

	// Ports can be used to indicate if the backend service is listening on HTTP or HTTPS
	// +optional
	Ports []IngressBackendPort `json:"ports,omitempty"`

	// TrustedRootCertificate can be used to supply a certificate for the gateway to trust when communicating to the
	// backend on a port specified as https
	// +optional
	TrustedRootCertificate string `json:"trustedRootCertificate,omitempty"`

	// SessionAffinity allows client requests to be consistently given to the same backend
	// +optional
	*SessionAffinity `json:"sessionAffinity,omitempty"`

	// Timeouts define a set of timeout parameters to be applied to an Ingress
	// +optional
	Timeouts IngressTimeouts `json:"timeouts,omitempty"`

	// LoadBalancing defines the load balancing policy for the backend service
	// +optional
	*BackendLoadBalancingPolicySpec `json:"loadBalancingPolicySpec,omitempty"`
}

type IngressExtension struct {
	// Object's type metadata.
	metav1.TypeMeta `json:",inline"`

	// Object's metadata.
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Spec is the IngressExtension specification.
	Spec IngressExtensionSpec `json:"spec,omitempty"`

	// +kubebuilder:default={conditions: {{type: "Accepted", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}}
	Status IngressExtensionStatus `json:"status"`
}

type IngressExtensionConditionReason string

type IngressExtensionConditionType string

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

type IngressExtensionSpec struct {
	// Rules define the rules per host
	// +optional
	Rules []IngressRuleSetting `json:"rules,omitempty"`

	// BackendSettings defines a set of configuration options for Ingress service backends
	// +optional
	BackendSettings []IngressBackendSettings `json:"backendSettings,omitempty"`
}

type IngressExtensionStatus struct {
	// Rules have detailed status information regarding each Rule
	// +optional
	Rules []IngressRuleStatus `json:"rules,omitempty"`

	// BackendSettings has detailed status information regarding each BackendSettings
	// +optional
	BackendSettings []IngressBackendSettingStatus `json:"backendSettings,omitempty"`

	// Conditions describe the current conditions of the IngressExtension.
	// +optional
	// Known condition types are:
	//
	// * "Accepted"
	// * "Errors"
	//
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=8
	// +kubebuilder:default={{type: "Accepted", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"},{type: "ValidationErrors", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type IngressRewrites struct {
	// Type identifies the type of rewrite
	// +kubebuilder:validation:Enum=RequestHeaderModifier;ResponseHeaderModifier;URLRewrite
	Type RewriteType `json:"type"`

	// RequestHeaderModifier defines a schema that modifies request headers.
	// +optional
	RequestHeaderModifier *HeaderFilter `json:"requestHeaderModifier,omitempty"`

	// RequestHeaderModifier defines a schema that modifies response headers.
	// +optional
	ResponseHeaderModifier *HeaderFilter `json:"responseHeaderModifier,omitempty"`

	// URLRewrite defines a schema that modifies a request during forwarding.
	// +optional
	URLRewrite *URLRewriteFilter `json:"urlRewrite,omitempty"`
}

type IngressRuleSetting struct {
	// Host is used to match against Ingress rules with the same hostname in order to identify which rules affect these settings
	Host string `json:"host"`

	// AdditionalHostnames specifies more hostnames to listen on
	// +optional
	AdditionalHostnames []string `json:"additionalHostnames,omitempty"`

	// Rewrites defines the rewrites for the rule
	// +optional
	Rewrites []IngressRewrites `json:"rewrites,omitempty"`

	// RequestRedirect defines the redirect behavior for the rule
	// +optional
	RequestRedirect *Redirect `json:"requestRedirect,omitempty"`
}

type IngressRuleStatus struct {
	// Host identifies the rule this status describes
	Host string `json:"host"`

	// Errors are a list of errors relating to this setting
	// +optional
	Errors []string `json:"validationErrors"`

	// Valid indicates that there are no validation errors present on this rule
	// +optional
	Valid bool `json:"valid"`
}

type IngressTimeouts struct {
	// RequestTimeout defines the timeout used by the load balancer when forwarding requests to a backend service
	// +optional
	RequestTimeout metav1.Duration `json:"requestTimeout,omitempty"`
}

type LoadAwareConfig struct {
	// An endpoint must report load metrics continuously for at least this long before the endpoint
	// metrics will be used to influence load balancing decisions. Takes effect both immediately after
	// we establish a connection to an endpoint and after `metricExpirationPeriod` has elapsed.
	// Default is 10 seconds.
	//
	// +optional
	BlackoutPeriod metav1.Duration `json:"blackoutPeriod"`

	// If the endpoint does not report load metrics for this duration, metrics will stop
	// being used to influence load balancing decisions. Default is 3 minutes.
	//
	// +optional
	MetricExpirationPeriod metav1.Duration `json:"metricExpirationPeriod"`

	// The multiplier used to adjust endpoint weights with the error rated calculated based
	// on the reported `rps_fractional` and `eps` load metrics. Must not be a negative value.
	// Default is 1.0.
	//
	// +optional
	// +kubebuilder:default=`1.0`
	// +kubebuilder:validation:Pattern=`^([0-9]+([.][0-9]+)?|[.][0-9]+)$`
	ErrorUtilizationPenalty string `json:"errorUtilizationPenalty,omitempty"`

	// A list of custom metrics reported by endpoints to be used for reporting utilization
	// and influencing load balancing decisions. Utilization will be computed by taking the
	// max of the values of metrics specified in this list.
	//
	// +optional
	// +kubebuilder:validation:MaxItems=10
	NamedMetrics []string `json:"namedMetrics,omitempty"`
}

type LoadBalancingConfig struct {
	// Strategy defines the policy to use when load balancing traffic to the backend service.
	// Default is round-robin.
	//
	// +optional
	Strategy LoadBalancingStrategy `json:"strategy,omitempty"`

	// SlowStart defines the schema for Slow Start specification
	// +optional
	SlowStart *SlowStartConfig `json:"slowStart,omitempty"`

	// LoadAware defines the schema for Load Aware Routing specification
	// +optional
	LoadAware *LoadAwareConfig `json:"loadAware,omitempty"`
}

type LoadBalancingStrategy string

type MTLSPolicyVerify struct {
	// CaCertificateRef is the CA certificate used to verify peer certificate.
	//
	// +kubebuilder:validation:Required
	CaCertificateRef *gatewayapi_v1.SecretObjectReference `json:"caCertificateRef,omitempty"`

	// SubjectAltNames is the list of subject alternative names used to verify peer
	// certificate.
	//
	// +optional
	SubjectAltNames []string `json:"subjectAltNames,omitempty"`
}

type PolicyConditionReason string

type PolicyConditionType string

type PolicyType struct {
	// Name is the name of the policy.
	Name FrontendTLSPolicyTypeName `json:"name"`

	// FrontendTLSPolicyType specifies the frontend TLS policy type
	FrontendTLSPolicyType FrontendTLSPolicyType `json:"type"`
}

type PortNumber int32

type PreciseHostname string

type Protocol string

type Redirect struct {
	// Scheme is the scheme to be used in the value of the `Location` header in
	// the response. When empty, the scheme of the request is used.
	//
	//
	// +optional
	// +kubebuilder:validation:Enum=http;https
	Scheme *string `json:"scheme,omitempty"`

	// Hostname is the hostname to be used in the value of the `Location`
	// header in the response.
	// When empty, the hostname in the `Host` header of the request is used.
	//
	// +optional
	Hostname *PreciseHostname `json:"hostname,omitempty"`

	// Path defines parameters used to modify the path of the incoming request.
	// The modified path is then used to construct the `Location` header. When
	// empty, the request path is used as-is.
	//
	// +optional
	Path *HTTPPathModifier `json:"path,omitempty"`

	// Port is the port to be used in the value of the `Location`
	// header in the response.
	//
	// If no port is specified, the redirect port MUST be derived using the
	// following rules:
	//
	// * If redirect scheme is not-empty, the redirect port MUST be the well-known
	//   port associated with the redirect scheme. Specifically "http" to port 80
	//   and "https" to port 443. If the redirect scheme doesn't have a
	//   well-known port, the listener port of the Gateway SHOULD be used.
	// * If redirect scheme is empty, the redirect port MUST be the Gateway
	//   Listener port.
	//
	// Implementations SHOULD NOT add the port number in the 'Location'
	// header in the following cases:
	//
	// * A Location header that uses HTTP (whether that is determined via
	//   the Listener protocol or the Scheme field) _and_ use port 80.
	// * A Location header that uses HTTPS (whether that is determined via
	//   the Listener protocol or the Scheme field) _and_ use port 443.
	//
	// +optional
	Port *PortNumber `json:"port,omitempty"`

	// StatusCode is the HTTP status code to be used in response.
	//
	// Values may be added to this enum, implementations
	// must ensure that unknown values won't cause a crash.
	//
	// +optional
	// +kubebuilder:default=302
	// +kubebuilder:validation:Enum=301;302;303;307;308
	StatusCode *int `json:"statusCode,omitempty"`
}

type RewriteType string

type RoutePolicy struct {
	// Object's type metadata.
	metav1.TypeMeta `json:",inline"`

	// Object's metadata.
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Spec is the RoutePolicy specification.
	Spec RoutePolicySpec `json:"spec,omitempty"`

	// Status defines the current state of RoutePolicy.
	//
	// +kubebuilder:default={conditions: {{type: "Accepted", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}}
	Status RoutePolicyStatus `json:"status,omitempty"`
}

type RoutePolicyConditionReason string

type RoutePolicyConditionType string

type RoutePolicyConfig struct {
	// Custom Timeouts
	// Timeout for the target resource.
	// +optional
	RouteTimeouts *RouteTimeouts `json:"timeouts,omitempty"`

	// SessionAffinity defines the schema for Session Affinity specification
	// +optional
	SessionAffinity *SessionAffinity `json:"sessionAffinity,omitempty"`
}

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

type RoutePolicySpec struct {
	// TargetRef identifies an API object to apply policy to.
	TargetRef CustomTargetRef `json:"targetRef"`

	// Override defines policy configuration that should override policy
	// configuration attached below the targeted resource in the hierarchy.
	//
	// Note: Override is currently not supported and result in a validation error.
	// Support for Override will be added in a future release.
	//
	// +optional
	Override *RoutePolicyConfig `json:"override,omitempty"`

	// Default defines default policy configuration for the targeted resource.
	//
	// +optional
	Default *RoutePolicyConfig `json:"default,omitempty"`
}

type RoutePolicyStatus struct {
	// Conditions describe the current conditions of the RoutePolicy.
	//
	// Implementations should prefer to express RoutePolicy conditions
	// using the `RoutePolicyConditionType` and `RoutePolicyConditionReason`
	// constants so that operators and tools can converge on a common
	// vocabulary to describe RoutePolicy state.
	//
	// +optional
	// Known condition types are:
	//
	// * "Accepted"
	//
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=8
	// +kubebuilder:default={{type: "Accepted", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type RouteTimeouts struct {
	// RouteTimeout is the timeout for the route.
	//
	// +optional
	RouteTimeout metav1.Duration `json:"routeTimeout,omitempty"`
}

type SessionAffinity struct {
	// +kubebuilder:validation:Required
	AffinityType AffinityType `json:"affinityType,omitempty"`

	// +optional
	CookieName string `json:"cookieName,omitempty"`

	// +optional
	CookieDuration metav1.Duration `json:"cookieDuration,omitempty"`
}

type SlowStartConfig struct {
	// The duration of the slow start window.
	// +required
	Window metav1.Duration `json:"window,omitempty"`

	// The speed of traffic increase over the slow start window, must be greater than 0.0.
	// Defaults to 1.0 if unspecified.
	//
	// +optional
	// +kubebuilder:default=`1.0`
	// +kubebuilder:validation:Pattern=`^([0-9]+([.][0-9]+)?|[.][0-9]+)$`
	Aggression string `json:"aggression,omitempty"`

	// The minimum or starting percentage of traffic to send to new endpoints.
	// Defaults to 10% if unspecified.
	//
	// +optional
	// +kubebuilder:default=10
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=100
	StartWeightPercent uint32 `json:"startWeightPercent,omitempty"`
}

type StatusCodes struct {
	// Start defines the start of the range of status codes to use for HealthCheck checks.
	// This is inclusive.
	//
	// +optional
	Start int32 `json:"start,omitempty"`

	// End defines the end of the range of status codes to use for HealthCheck checks.
	// This is inclusive.
	//
	// +optional
	End int32 `json:"end,omitempty"`
}

type TargetRefSpec struct {
	// TargetRef identifies an API object to apply policy to.
	TargetRef CustomTargetRef `json:"targetRef"`

	// Ports specifies the list of ports on the target where the policy is applied.
	// +optional
	Ports []BackendLoadBalancingPolicyPort `json:"ports,omitempty"`
}

type URLRewriteFilter struct {
	// Hostname is the value to be used to replace the Host header value during
	// forwarding.
	// +optional
	Hostname *PreciseHostname `json:"hostname,omitempty"`

	// Path defines a path rewrite.
	// +optional
	Path *HTTPPathModifier `json:"path,omitempty"`
}

type WebApplicationFirewallConfig struct {
	ID string `json:"id"`
}

type WebApplicationFirewallPolicy struct {
	// Object's type metadata.
	metav1.TypeMeta `json:",inline"`

	// Object's metadata.
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Spec is the specifications for Application Gateway for Containers Security Policy child resource.
	Spec WebApplicationFirewallPolicySpec `json:"spec,omitempty"`

	// Status defines the current state of Application Gateway for Containers Security Policy child resource.
	//
	// +kubebuilder:default={conditions: {{type: "Accepted", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}}
	Status WebApplicationFirewallPolicyStatus `json:"status,omitempty"`
}

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

type WebApplicationFirewallPolicySpec struct {
	// TargetRef identifies an API object to apply policy to.
	TargetRef CustomTargetRef `json:"targetRef"`

	// WebApplicationFirewallPolicy is used to specify a WebApplicationPolicy resource
	WebApplicationFirewallPolicy *WebApplicationFirewallConfig `json:"webApplicationFirewall,omitempty"`
}

type WebApplicationFirewallPolicyStatus struct {

	// +optional
	// Known condition types are:
	//
	// * "Accepted"
	// * "Deployment"
	// * "ResolvedRefs"
	// * "Programmed"
	//
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=8
	// +kubebuilder:default={{type: "Accepted", status: "Unknown", reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}