v1alpha1

type ACL struct {
	// Name
	// +kubebuilder:validation:Pattern=^[^\s]+$
	Name string `json:"name"`
	// Criterion is the name of a sample fetch method, or one of its ACL
	// specific declinations.
	// +kubebuilder:validation:Pattern=^[^\s]+$
	Criterion string `json:"criterion"`
	// Values are of the type supported by the criterion.
	Values []string `json:"values"`
}

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

	Spec   BackendSpec `json:"spec,omitempty"`
	Status Status      `json:"status,omitempty"`
}

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

type BackendReference struct {
	// Name of a specific backend
	Name *string `json:"name,omitempty"`
	// Mapping of multiple backends
	RegexMapping *RegexBackendMapping `json:"regexMapping,omitempty"`
}

type BackendSpec struct {
	BaseSpec `json:",inline"`
	// CheckTimeout sets an additional check timeout, but only after a connection has been already
	// established.
	// +optional
	CheckTimeout *metav1.Duration `json:"checkTimeout,omitempty"`
	// Servers defines the backend servers and its configuration.
	Servers []Server `json:"servers,omitempty"`
	// ServerTemplates defines the backend server templates and its configuration.
	ServerTemplates []ServerTemplate `json:"serverTemplates,omitempty"`
	// Balance defines the load balancing algorithm to be used in a backend.
	// +optional
	Balance *Balance `json:"balance,omitempty"`
	// HostRegex specifies a regular expression used for backend switching rules.
	// +optional
	HostRegex string `json:"hostRegex,omitempty"`
	// HostCertificate specifies a certificate for that host used in the crt-list of a frontend
	// +optional
	HostCertificate *CertificateListElement `json:"hostCertificate,omitempty"`
	// Redispatch enable or disable session redistribution in case of connection failure
	// +optional
	Redispatch *bool `json:"redispatch,omitempty"`
	// HashType specifies a method to use for mapping hashes to servers
	// +optional
	HashType *HashType `json:"hashType,omitempty"`
	// Cookie enables cookie-based persistence in a backend.
	// +optional
	Cookie *Cookie `json:"cookie,omitempty"`
	// HTTPChk Enables HTTP protocol to check on the servers health
	// +optional
	HTTPChk *HTTPChk `json:"httpchk,omitempty"`
	// TCPCheck Perform health checks using tcp-check send/expect sequences
	// +optional
	TCPCheck *bool `json:"tcpCheck,omitempty"`
}

type BackendSwitchingRule struct {
	Rule `json:",inline"`
	// Backend reference used to resolve the backend name.
	Backend BackendReference `json:"backend,omitempty"`
}

type Balance struct {
	// Algorithm is the algorithm used to select a server when doing load balancing. This only applies when no persistence information is available, or when a connection is redispatched to another server.
	// +kubebuilder:validation:Enum=roundrobin;static-rr;leastconn;first;source;uri;hdr;random;rdp-cookie
	Algorithm string `json:"algorithm"`
}

type BaseSpec struct {
	// Mode can be either 'tcp' or 'http'. In TCP mode it is a layer 4 proxy. In HTTP mode it is a layer 7 proxy.
	// +kubebuilder:default=http
	// +kubebuilder:validation:Enum=http;tcp
	Mode string `json:"mode"`
	// HTTPResponse rules define a set of rules which apply to layer 7 processing.
	// +optional
	HTTPResponse *HTTPResponseRules `json:"httpResponse,omitempty"`
	// HTTPRequest rules define a set of rules which apply to layer 7 processing.
	// +optional
	HTTPRequest *HTTPRequestRules `json:"httpRequest,omitempty"`
	// TCPRequest rules perform an action on an incoming connection depending on a layer 4 condition.
	// +optional
	TCPRequest []TCPRequestRule `json:"tcpRequest,omitempty"`
	// ACL (Access Control Lists) provides a flexible solution to perform
	// content switching and generally to take decisions based on content extracted
	// from the request, the response or any environmental status
	// +optional
	ACL []ACL `json:"acl,omitempty"`
	// Timeouts: check, connect, http-keep-alive, http-request, queue, server, tunnel.
	// The timeout value specified in milliseconds by default, but can be in any other unit if the number is suffixed by the unit.
	// More info: https://cbonte.github.io/haproxy-dconv/2.6/configuration.html
	// +optional
	Timeouts map[string]metav1.Duration `json:"timeouts"`
	// ErrorFiles custom error files to be used
	// +optional
	ErrorFiles []*ErrorFile `json:"errorFiles,omitempty"`
	// Forwardfor enable insertion of the X-Forwarded-For header to requests sent to servers
	// +optional
	Forwardfor *Forwardfor `json:"forwardFor,omitempty"`
	// HTTPPretendKeepalive will keep the connection alive. It is recommended not to enable this option by default.
	// +optional
	HTTPPretendKeepalive *bool `json:"httpPretendKeepalive,omitempty"`
}

type Bind struct {
	// Name for these sockets, which will be reported on the stats page.
	Name string `json:"name"`
	// Address can be a host name, an IPv4 address, an IPv6 address, or '*' (is equal to the special address "0.0.0.0").
	// +kubebuilder:validation:Pattern=^[^\s]+$
	// +optional
	Address string `json:"address,omitempty"`
	// Port
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port int64 `json:"port"`
	// PortRangeEnd if set it must be greater than Port
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	// +optional
	PortRangeEnd *int64 `json:"portRangeEnd,omitempty"`
	// Transparent is an optional keyword which is supported only on certain Linux kernels. It
	// indicates that the addresses will be bound even if they do not belong to the
	// local machine, and that packets targeting any of these addresses will be
	// intercepted just as if the addresses were locally configured. This normally
	// requires that IP forwarding is enabled. Caution! do not use this with the
	// default address '*', as it would redirect any traffic for the specified port.
	// +optional
	Transparent bool `json:"transparent,omitempty"`
	// SSL configures OpenSSL
	// +optional
	SSL *SSL `json:"ssl,omitempty"`
	// This setting is only available when support for OpenSSL was built in. It
	// designates a list of PEM file with an optional ssl configuration and a SNI
	// filter per certificate.
	// +optional
	SSLCertificateList *CertificateList `json:"sslCertificateList,omitempty"`
	// Hidden hides the bind and prevent exposing the Bind in services or routes
	// +optional
	Hidden *bool `json:"hidden,omitempty"`
	// AcceptProxy enforces the use of the PROXY protocol over any connection accepted by any of
	// the sockets declared on the same line.
	// +optional
	AcceptProxy *bool `json:"acceptProxy,omitempty"`
}

type CertificateList struct {
	// Name is the name of the certificate list
	Name string `json:"name"`
	// Elements is a list of SSL configuration and a SNI filter per certificate. If backend switching based on regex is used the host certificate
	Elements []CertificateListElement `json:"elements,omitempty"`
	// LabelSelector to select multiple backend certificates
	LabelSelector *metav1.LabelSelector `json:"selector,omitempty"`
}

type CertificateListElement struct {
	// Certificate that will be presented to clients who provide a valid
	// TLSServerNameIndication field matching the SNIFilter.
	Certificate SSLCertificate `json:"certificate"`
	// SNIFilter specifies the filter for the SSL Certificate.  Wildcards are supported in the SNIFilter. Negative filter are also supported.
	SNIFilter string `json:"sniFilter"`
	// Alpn enables the TLS ALPN extension and advertises the specified protocol
	// list as supported on top of ALPN.
	// +optional
	Alpn []string `json:"alpn,omitempty"`
}

type Check struct {
	// Enable enables health checks on a server. If not set, no health checking is performed, and the server is always
	// considered available.
	Enabled bool `json:"enabled"`
	// Inter sets the interval between two consecutive health checks. If left unspecified, the delay defaults to 2000 ms.
	// +optional
	Inter *metav1.Duration `json:"inter,omitempty"`
	// Rise specifies the number of consecutive successful health checks after a server will be considered as operational.
	// This value defaults to 2 if unspecified.
	// +optional
	Rise *int64 `json:"rise,omitempty"`
	// Fall specifies the number of consecutive unsuccessful health checks after a server will be considered as dead.
	// This value defaults to 3 if unspecified.
	// +optional
	Fall *int64 `json:"fall,omitempty"`
}

type Cookie struct {
	// Name of the cookie which will be monitored, modified or inserted in order to bring persistence.
	Name string `json:"name,omitempty"`
	// Mode could be 'rewrite', 'insert', 'prefix'. Select one.
	// +optional
	Mode CookieMode `json:"mode,omitempty"`
	// Indirect no cookie will be emitted to a client which already has a valid one
	// for the server which has processed the request.
	// +optional
	Indirect *bool `json:"indirect,omitempty"`
	// NoCache recommended in conjunction with the insert mode when there is a cache
	// between the client and HAProx
	// +optional
	NoCache *bool `json:"noCache,omitempty"`
	// PostOnly ensures that cookie insertion will only be performed on responses to POST requests.
	// +optional
	PostOnly *bool `json:"postOnly,omitempty"`
	// Preserve only be used with "insert" and/or "indirect". It allows the server
	// to emit the persistence cookie itself.
	// +optional
	Preserve *bool `json:"preserve,omitempty"`
	// HTTPOnly add an "HttpOnly" cookie attribute when a cookie is inserted.
	// It doesn't share the cookie with non-HTTP components.
	// +optional
	HTTPOnly *bool `json:"httpOnly,omitempty"`
	// Secure add a "Secure" cookie attribute when a cookie is inserted. The user agent
	// never emits this cookie over non-secure channels. The cookie will be presented
	// only over SSL/TLS connections.
	// +optional
	Secure *bool `json:"secure,omitempty"`
	// Dynamic activates dynamic cookies, when used, a session cookie is dynamically created for each server,
	// based on the IP and port of the server, and a secret key.
	// +optional
	Dynamic *bool `json:"dynamic,omitempty"`
	// Domain specify the domain at which a cookie is inserted. You can specify
	// several domain names by invoking this option multiple times.
	// +optional
	Domain []string `json:"domain,omitempty"`
	// MaxIdle cookies are ignored after some idle time.
	// +optional
	MaxIdle int64 `json:"maxIdle,omitempty"`
	// MaxLife cookies are ignored after some life time.
	// +optional
	MaxLife int64 `json:"maxLife,omitempty"`
	// Attribute add an extra attribute when a cookie is inserted.
	// +optional
	Attribute []string `json:"attribute,omitempty"`
}

type CookieMode struct {
	// Rewrite the cookie will be provided by the server.
	Rewrite bool `json:"rewrite"`
	// Insert cookie will have to be inserted by haproxy in server responses.
	Insert bool `json:"insert"`
	// Prefix is needed in some specific environments where the client does not support
	// more than one single cookie and the application already needs it.
	Prefix bool `json:"prefix"`
}

type Deny struct {
	Rule `json:",inline"`
	// Enabled enables deny http request
	Enabled bool `json:"enabled"`
	// DenyStatus is the HTTP status code.
	// +kubebuilder:validation:Minimum=200
	// +kubebuilder:validation:Maximum=599
	// +optional
	DenyStatus *int64 `json:"denyStatus,omitempty"`
}

type ErrorFile struct {
	// Code is the HTTP status code.
	// +kubebuilder:validation:Enum=200;400;401;403;404;405;407;408;410;413;425;429;500;501;502;503;504
	Code int64 `json:"code"`
	// File designates a file containing the full HTTP response.
	File StaticHTTPFile `json:"file"`
}

type ErrorFileValueFrom struct {
	// ConfigMapKeyRef selects a key of a ConfigMap.
	// +optional
	ConfigMapKeyRef *corev1.ConfigMapKeySelector `json:"configMapKeyRef,omitempty"`
}

type Forwardfor struct {
	Enabled bool `json:"enabled"`
	// Pattern: ^[^\s]+$
	Except string `json:"except,omitempty"`
	// Pattern: ^[^\s]+$
	Header string `json:"header,omitempty"`
	Ifnone bool   `json:"ifnone,omitempty"`
}

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

	Spec   FrontendSpec `json:"spec,omitempty"`
	Status Status       `json:"status,omitempty"`
}

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

type FrontendSpec struct {
	BaseSpec `json:",inline"`
	// Binds defines the frontend listening addresses, ports and its configuration.
	// +kubebuilder:validation:MinItems=1
	Binds []Bind `json:"binds"`
	// BackendSwitching rules specify the specific backend used if/unless an ACL-based condition is matched.
	// +optional
	BackendSwitching []BackendSwitchingRule `json:"backendSwitching,omitempty"`
	// DefaultBackend to use when no 'use_backend' rule has been matched.
	DefaultBackend corev1.LocalObjectReference `json:"defaultBackend"`
	// HTTPLog enables HTTP log format which is the most complete and the best suited for HTTP proxies. It provides
	// the same level of information as the TCP format with additional features which
	// are specific to the HTTP protocol.
	// +optional
	HTTPLog *bool `json:"httpLog,omitempty"`
	// TCPLog enables advanced logging of TCP connections with session state and timers. By default, the log output format
	// is very poor, as it only contains the source and destination addresses, and the instance name.
	// +optional
	TCPLog *bool `json:"tcpLog,omitempty"`
}

type HTTPChk struct {
	// URI
	URI string `json:"uri,omitempty"`
	// Method http method
	// +optional
	// Enum: [HEAD PUT POST GET TRACE PATCH DELETE CONNECT OPTIONS]
	// +kubebuilder:validation:Enum=HEAD;PUT;POST;GET;TRACE;PATCH;DELETE;CONNECT;OPTIONS;
	Method string `json:"method,omitempty"`
}

type HTTPDeleteHeaderRule struct {
	Rule `json:",inline"`
	// Name specifies the header name
	Name string `json:"name"`
	// Method is the matching applied on the header name
	// +kubebuilder:validation:Enum=str;beg;end;sub;reg
	Method string `json:"method"`
}

type HTTPHeaderRule struct {
	Rule `json:",inline"`
	// Name specifies the header name
	Name string `json:"name"`
	// Value specifies the header value
	Value HTTPHeaderValue `json:"value"`
}

type HTTPHeaderValue struct {
	// Env variable with the header value
	Env *corev1.EnvVar `json:"env,omitempty"`
	// Str with the header value
	Str *string `json:"str,omitempty"`
	// Format specifies the format of the header value (implicit default is '%s')
	Format *string `json:"format,omitempty"`
}

type HTTPPathRule struct {
	Rule `json:",inline"`
	// Value specifies the path value
	Value string `json:"format,omitempty"`
}

type HTTPPretendKeepalive struct {
	Enabled bool `json:"enabled"`
}

type HTTPRequestRules struct {
	// SetHeader sets HTTP header fields
	SetHeader []HTTPHeaderRule `json:"setHeader,omitempty"`
	// SetPath sets request path
	SetPath []HTTPPathRule `json:"setPath,omitempty"`
	// AddHeader appends HTTP header fields
	AddHeader []HTTPHeaderRule `json:"addHeader,omitempty"`
	// DelHeader removes all HTTP header fields
	DelHeader []HTTPDeleteHeaderRule `json:"delHeader,omitempty"`
	// Redirect performs an HTTP redirection based on a redirect rule.
	// +optional
	Redirect []Redirect `json:"redirect,omitempty"`
	// ReplacePath matches the value of the path using a regex and completely replaces it with the specified format.
	// The replacement does not modify the scheme, the authority and the query-string.
	// +optional
	ReplacePath []ReplacePath `json:"replacePath,omitempty"`
	// Deny stops the evaluation of the rules and immediately rejects the request and emits an HTTP 403 error.
	// Optionally the status code specified as an argument to deny_status.
	// +optional
	Deny []Deny `json:"deny,omitempty"`
	// Return stops the evaluation of the rules and immediately returns a response.
	Return *HTTPReturn `json:"return,omitempty"`
}

type HTTPResponseRules struct {
	// SetHeader sets HTTP header fields
	SetHeader []HTTPHeaderRule `json:"setHeader,omitempty"`
}

type HTTPReturn struct {
	// Status can be optionally specified, the default status code used for the response is 200.
	// +kubebuilder:default=200
	Status *int64 `json:"status,omitempty"`
	// Content is a full HTTP response specifying the errorfile to use, or the response payload specifying the file or the string to use.
	Content HTTPReturnContent `json:"content"`
}

type HTTPReturnContent struct {
	// Type specifies the content-type of the HTTP response.
	Type string `json:"type"`
	// ContentFormat defines the format of the Content. Can be one an errorfile or a string.
	// +kubebuilder:validation:Enum=default-errorfile;errorfile;errorfiles;file;lf-file;string;lf-string
	Format string `json:"format"`
	// Value specifying the file or the string to use.
	Value string `json:"value"`
}

type HashType struct {
	// +kubebuilder:validation:Enum=map-based;consistent
	// +optional
	Method string `json:"method,omitempty"`
	// +kubebuilder:validation:Enum=sdbm;djb2;wt6;crc32
	// +optional
	Function string `json:"function,omitempty"`
	// +kubebuilder:validation:Enum=avalanche
	// +optional
	Modifier string `json:"modifier,omitempty"`
}

type Hold struct {
	// Nx defines interval between two successive name resolution when the last answer was nx.
	Nx *metav1.Duration `json:"nx,omitempty"`
	// Obsolete defines interval between two successive name resolution when the last answer was obsolete.
	Obsolete *metav1.Duration `json:"obsolete,omitempty"`
	// Other defines interval between two successive name resolution when the last answer was other.
	Other *metav1.Duration `json:"other,omitempty"`
	// Refused defines interval between two successive name resolution when the last answer was nx.
	Refused *metav1.Duration `json:"refused,omitempty"`
	// Timeout defines interval between two successive name resolution when the last answer was timeout.
	Timeout *metav1.Duration `json:"timeout,omitempty"`
	// Valid defines interval between two successive name resolution when the last answer was valid.
	Valid *metav1.Duration `json:"valid,omitempty"`
}

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

	Spec   ListenSpec `json:"spec,omitempty"`
	Status Status     `json:"status,omitempty"`
}

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

type ListenSpec struct {
	BaseSpec `json:",inline"`
	// Binds defines the frontend listening addresses, ports and its configuration.
	// +kubebuilder:validation:MinItems=1
	Binds []Bind `json:"binds"`
	// Servers defines the backend servers and its configuration.
	// +optional
	Servers []Server `json:"servers,omitempty"`
	// ServerTemplates defines the backend server templates and its configuration.
	// +optional
	ServerTemplates []ServerTemplate `json:"serverTemplates,omitempty"`
	// CheckTimeout sets an additional check timeout, but only after a connection has been already
	// established.
	// +optional
	CheckTimeout *metav1.Duration `json:"checkTimeout,omitempty"`
	// Balance defines the load balancing algorithm to be used in a backend.
	// +optional
	Balance *Balance `json:"balance,omitempty"`
	// Redispatch enable or disable session redistribution in case of connection failure
	// +optional
	Redispatch *bool `json:"redispatch,omitempty"`
	// HashType Specify a method to use for mapping hashes to servers
	// +optional
	HashType *HashType `json:"hashType,omitempty"`
	// Cookie enables cookie-based persistence in a backend.
	// +optional
	Cookie *Cookie `json:"cookie,omitempty"`
	// HostCertificate specifies a certificate for that host used in the crt-list of a frontend
	// +optional
	HostCertificate *CertificateListElement `json:"hostCertificate,omitempty"`
	// HTTPCheck Enables HTTP protocol to check on the servers health
	// +optional
	HTTPCheck *HTTPChk `json:"httpCheck,omitempty"`
	// TCPCheck Perform health checks using tcp-check send/expect sequences
	// +optional
	TCPCheck *bool `json:"tcpCheck,omitempty"`
}

type Nameserver struct {
	// Name specifies a unique name of the nameserver.
	// +kubebuilder:validation:Pattern="^[A-Za-z0-9-_.:]+$"
	Name string `json:"name"`
	// Address
	// +kubebuilder:validation:Pattern=^[^\s]+$
	Address string `json:"address"`
	// Port
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port int64 `json:"port,omitempty"`
}

type Object interface {
	client.Object
	SetStatus(status Status)
	GetStatus() Status
	AddToParser(p parser.Parser) error
}

type ProxyProtocol struct {
	// V1 parameter enforces use of the PROXY protocol version 1.
	// +optional
	V1 bool `json:"v1"`
	// V2 parameter enforces use of the PROXY protocol version 2.
	// +optional
	V2 *ProxyProtocolV2 `json:"v2"`
	// V2SSL parameter add the SSL information extension of the PROXY protocol to the PROXY protocol header.
	// +optional
	V2SSL bool `json:"v2SSL"`
	// V2SSLCN parameter add the SSL information extension of the PROXY protocol to the PROXY protocol header and he SSL information extension
	// along with the Common Name from the subject of the client certificate (if any), is added to the PROXY protocol header.
	// +optional
	V2SSLCN bool `json:"v2SSLCN"`
}

type ProxyProtocolV2 struct {
	// Enabled enables the PROXY protocol version 2.
	// +optional
	Enabled bool `json:"enabled"`
	// Options is a list of options to add to the PROXY protocol header.
	// +optional
	Options *ProxyProtocolV2Options `json:"options,omitempty"`
}

type ProxyProtocolV2Options struct {
	// Ssl is equivalent to use V2SSL.
	// +optional
	Ssl bool `json:"ssl"`
	// CertCn is equivalent to use V2SSLCN.
	// +optional
	CertCn bool `json:"certCn"`
	// SslCipher is the name of the used cipher.
	// +optional
	SslCipher bool `json:"sslCipher"`
	// CertSig is the signature algorithm of the used certificate.
	// +optional
	CertSig bool `json:"certSig"`
	// CertKey is the key algorithm of the used certificate.
	// +optional
	CertKey bool `json:"certKey"`
	// Authority is the host name value passed by the client (only SNI from a TLS)
	// +optional
	Authority bool `json:"authority"`
	// Crc32c is the checksum of the PROXYv2 header.
	// +optional
	Crc32c bool `json:"crc32C"`
	// UniqueId sends a unique ID generated using the frontend's "unique-id-format" within the PROXYv2 header.
	// This unique-id is primarily meant for "mode tcp". It can lead to unexpected results in "mode http".
	// +optional
	UniqueID bool `json:"uniqueID"`
}

type Redirect struct {
	// +optional
	Rule `json:",inline"`
	// Code indicates which type of HTTP redirection is desired.
	// +kubebuilder:validation:Enum=301;302;303;307;308
	// +optional
	Code *int64 `json:"code,omitempty"`
	// Type selects a mode and value to redirect
	// +optional
	Type RedirectType `json:"type,omitempty"`
	// Value to redirect
	// +optional
	Value string `json:"value,omitempty"`
	// Value to redirect
	// +optional
	Option *RedirectOption `json:"option,omitempty"`
}

type RedirectCookie struct {
	// Name
	// +optional
	Name string `json:"name,omitempty"`
	// Value
	// +optional
	Value string `json:"value,omitempty"`
}

type RedirectOption struct {
	// DropQuery removes the query string from the original URL when performing the concatenation.
	// +optional
	DropQuery bool `json:"dropQuery,omitempty"`
	// AppendSlash adds a / character at the end of the URL.
	// +optional
	AppendSlash bool `json:"appendSlash,omitempty"`
	// SetCookie adds header to the redirection. It will be added with NAME (and optionally "=value")
	// +optional
	SetCookie *RedirectCookie `json:"SetCookie,omitempty"`
	// ClearCookie is to instruct the browser to delete the cookie. It will be added with NAME (and optionally "=").
	// To add "=" type any string in the value field
	// +optional
	ClearCookie *RedirectCookie `json:"ClearCookie,omitempty"`
}

type RedirectType struct {
	// Location replaces the entire location of a URL.
	// +optional
	Location bool `json:"location"`
	// Prefix adds a prefix to the URL's location.
	// +optional
	Prefix bool `json:"insert"`
	// Scheme redirects to a different scheme.
	// +optional
	Scheme bool `json:"prefix"`
}

type RegexBackendMapping struct {
	// Name to identify the mapping
	Name string `json:"name"`
	// Parameter which will be used for the mapping (default: base)
	// +kubebuilder:default=base
	Parameter string `json:"parameter"`
	// LabelSelector to select multiple backends
	LabelSelector metav1.LabelSelector `json:"selector"`
}

type ReplacePath struct {
	Rule `json:",inline"`
	// MatchRegex is a string pattern used to identify the paths that need to be replaced.
	MatchRegex string `json:"matchRegex"`
	// ReplaceFmt defines the format string used to replace the values that match the pattern.
	ReplaceFmt string `json:"replaceFmt"`
}

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

	Spec   ResolverSpec `json:"spec,omitempty"`
	Status Status       `json:"status,omitempty"`
}

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

type ResolverSpec struct {
	// Nameservers used to configure a nameservers.
	Nameservers []Nameserver `json:"nameservers,omitempty"`
	// AcceptedPayloadSize defines the maximum payload size accepted by HAProxy and announced to all the  name servers
	// configured in this resolver.
	// +kubebuilder:validation:Maximum=8192
	// +kubebuilder:validation:Minimum=512
	// +optional
	AcceptedPayloadSize *int64 `json:"acceptedPayloadSize,omitempty"`
	// ParseResolvConf if true, adds all nameservers found in /etc/resolv.conf to this resolvers nameservers list.
	// +optional
	ParseResolvConf *bool `json:"parseResolvConf,omitempty"`
	// ResolveRetries defines the number <nb> of queries to send to resolve a server name before giving up. Default value: 3
	// +kubebuilder:validation:Minimum=1
	// +optional
	ResolveRetries *int64 `json:"resolveRetries,omitempty"`
	// Hold defines the period during which the last name resolution should be kept based on the last resolution status.
	// +optional
	Hold *Hold `json:"hold,omitempty"`
	// Timeouts defines timeouts related to name resolution.
	// +optional
	Timeouts *Timeouts `json:"timeouts,omitempty"`
}

type Rule struct {
	// ConditionType specifies the type of the condition matching ('if' or 'unless')
	// +kubebuilder:validation:Enum=if;unless
	// +optional
	ConditionType string `json:"conditionType,omitempty"`
	// Condition is a condition composed of ACLs.
	// +optional
	Condition string `json:"condition,omitempty"`
}

type SSL struct {
	// Enabled enables SSL deciphering on connections instantiated from this listener. A
	// certificate is necessary. All contents in the buffers will
	// appear in clear text, so that ACLs and HTTP processing will only have access
	// to deciphered contents. SSLv3 is disabled per default, set MinVersion to SSLv3
	// to enable it.
	Enabled bool `json:"enabled"`
	// MinVersion enforces use of the specified version or upper on SSL connections
	// instantiated from this listener.
	// +kubebuilder:validation:Enum=SSLv3;TLSv1.0;TLSv1.1;TLSv1.2;TLSv1.3
	// +optional
	MinVersion string `json:"minVersion,omitempty"`
	// Verify is only available when support for OpenSSL was built in. If set
	// to 'none', client certificate is not requested. This is the default. In other
	// cases, a client certificate is requested. If the client does not provide a
	// certificate after the request and if 'Verify' is set to 'required', then the
	// handshake is aborted, while it would have succeeded if set to 'optional'. The verification
	// of the certificate provided by the client using CAs from CACertificate.
	// On verify failure the handshake abortes, regardless of the 'verify' option.
	// +kubebuilder:validation:Enum=none;optional;required
	// +optional
	Verify string `json:"verify,omitempty"`
	// CACertificate configures the CACertificate used for the Server or Bind client certificate
	// +optional
	CACertificate *SSLCertificate `json:"caCertificate,omitempty"`
	// Certificate configures a PEM based Certificate file containing both the required certificates and any
	// associated private keys.
	// +optional
	Certificate *SSLCertificate `json:"certificate,omitempty"`
	// SNI parameter evaluates the sample fetch expression, converts it to a
	// string and uses the result as the host name sent in the SNI TLS extension to
	// the server.
	// +optional
	SNI string `json:"sni,omitempty"`
	// Alpn enables the TLS ALPN extension and advertises the specified protocol
	// list as supported on top of ALPN.
	// +optional
	Alpn []string `json:"alpn,omitempty"`
}

type SSLCertificate struct {
	Name      string                    `json:"name"`
	Value     *string                   `json:"value,omitempty"`
	ValueFrom []SSLCertificateValueFrom `json:"valueFrom,omitempty"`
}

type SSLCertificateValueFrom struct {
	// ConfigMapKeyRef selects a key of a ConfigMap
	// +optional
	ConfigMapKeyRef *corev1.ConfigMapKeySelector `json:"configMapKeyRef,omitempty"`
	// SecretKeyRef selects a key of a secret in the pod namespace
	// +optional
	SecretKeyRef *corev1.SecretKeySelector `json:"secretKeyRef,omitempty"`
}

type Server struct {
	ServerParams `json:",inline"`
	// Name of the server.
	Name string `json:"name"`
	// Address can be a host name, an IPv4 address, an IPv6 address.
	// +kubebuilder:validation:Pattern=^[^\s]+$
	Address string `json:"address"`
	// Port
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port int64 `json:"port"`
}

type ServerParams struct {
	// SSL configures OpenSSL
	// +optional
	SSL *SSL `json:"ssl,omitempty"`
	// Weight parameter is used to adjust the server weight relative to
	// other servers. All servers will receive a load proportional to their weight
	// relative to the sum of all weights.
	// +kubebuilder:validation:Maximum=256
	// +kubebuilder:validation:Minimum=0
	Weight *int64 `json:"weight,omitempty"`
	// Check configures the health checks of the server.
	// +optional
	Check *Check `json:"check,omitempty"`
	// InitAddr indicates in what order the server address should be resolved upon startup if it uses an FQDN.
	// Attempts are made to resolve the address by applying in turn each of the methods mentioned in the comma-delimited
	// list. The first method which succeeds is used.
	// +optional
	InitAddr *string `json:"initAddr,omitempty"`
	// Resolvers points to an existing resolvers to resolve current server hostname.
	// +optional
	Resolvers *corev1.LocalObjectReference `json:"resolvers,omitempty"`
	// SendProxy enforces use of the PROXY protocol over any
	// connection established to this server. The PROXY protocol informs the other
	// end about the layer 3/4 addresses of the incoming connection, so that it can
	// know the client address or the public address it accessed to, whatever the
	// upper layer protocol.
	// +optional
	SendProxy *bool `json:"sendProxy,omitempty"`
	// SendProxyV2 preparing new update.
	SendProxyV2 *ProxyProtocol `json:"SendProxyV2,omitempty"`
	// VerifyHost is only available when support for OpenSSL was built in, and
	// only takes effect if pec.ssl.verify' is set to 'required'. This directive sets
	// a default static hostname to check the server certificate against when no
	// SNI was used to connect to the server.
	// +optional
	VerifyHost string `json:"verifyHost,omitempty"`
	// CheckSNI This option allows you to specify the SNI to be used when doing health checks over SSL
	// +optional
	CheckSNI string `json:"checkSNI,omitempty"`
	// Cookie sets the cookie value assigned to the server.
	// +optional
	Cookie bool `json:"cookie,omitempty"`
}

type ServerTemplate struct {
	ServerParams `json:",inline"`
	// Prefix for the server names to be built.
	// +kubebuilder:validation:Pattern=^[^\s]+$
	Prefix string `json:"prefix"`
	// NumMin is the min number of servers as server name suffixes this template initializes.
	// +optional
	NumMin *int64 `json:"numMin,omitempty"`
	// Num is the max number of servers as server name suffixes this template initializes.
	Num int64 `json:"num"`
	// FQDN for all the servers this template initializes.
	FQDN string `json:"fqdn"`
	// Port
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port int64 `json:"port"`
}

type StaticHTTPFile struct {
	Name      string             `json:"name"`
	Value     *string            `json:"value,omitempty"`
	ValueFrom ErrorFileValueFrom `json:"valueFrom,omitempty"`
}

type Status struct {
	// Phase is a simple, high-level summary of where the object is in its lifecycle.
	Phase StatusPhase `json:"phase"`
	// ObservedGeneration the generation observed by the controller.
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
	// Error shows the actual error message if Phase is 'Error'.
	// +optional
	Error string `json:"error,omitempty"`
}

type StatusPhase string

type TCPRequestRule struct {
	Rule `json:",inline"`
	// Type specifies the type of the tcp-request rule.
	// +kubebuilder:validation:Enum=connection;content;inspect-delay;session
	Type string `json:"type"`
	// Action defines the action to perform if the condition applies.
	// +kubebuilder:validation:Enum=accept;capture;do-resolve;expect-netscaler-cip;expect-proxy;reject;sc-inc-gpc0;sc-inc-gpc1;sc-set-gpt0;send-spoe-group;set-dst-port;set-dst;set-priority;set-src;set-var;silent-drop;track-sc0;track-sc1;track-sc2;unset-var;use-service;lua
	// +optional
	Action *string `json:"action"`
	// Timeout sets timeout for the action
	// +optional
	Timeout *metav1.Duration `json:"timeout"`
}

type Timeouts struct {
	// Resolve time to trigger name resolutions when no other time applied. Default value: 1s
	// +optional
	Resolve *metav1.Duration `json:"resolve,omitempty"`
	// Retry time between two DNS queries, when no valid response have been received. Default value: 1s
	// +optional
	Retry *metav1.Duration `json:"retry,omitempty"`
}