// Copyright (c) 2026 Tigera, Inc. All rights reserved.

// Code generated by applyconfiguration-gen. DO NOT EDIT.

package v3

import (
	projectcalicov3 "github.com/projectcalico/api/pkg/apis/projectcalico/v3"
	numorstring "github.com/projectcalico/api/pkg/lib/numorstring"
	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

// FelixConfigurationSpecApplyConfiguration represents a declarative configuration of the FelixConfigurationSpec type for use
// with apply.
//
// FelixConfigurationSpec contains the values of the Felix configuration.
type FelixConfigurationSpecApplyConfiguration struct {
	// NodeSelector is an optional label selector that restricts this FelixConfiguration
	// to apply only to nodes that match the given selector. This field is only valid
	// on FelixConfiguration resources whose name is not "default" and does not start
	// with "node.". For resources named "default", the configuration applies globally
	// to all nodes. For resources named "node.<nodename>", the configuration applies to
	// the named node only.
	//
	// At most one selector-scoped FelixConfiguration should match any given node.
	// If multiple selector-scoped resources match, the oldest (by creation
	// timestamp) is used and a warning is logged. This prevents an accidentally
	// created conflicting resource from disrupting an existing, working
	// configuration.
	NodeSelector *string `json:"nodeSelector,omitempty"`
	// UseInternalDataplaneDriver, if true, Felix will use its internal dataplane programming logic.  If false, it
	// will launch an external dataplane driver and communicate with it over protobuf.
	UseInternalDataplaneDriver *bool `json:"useInternalDataplaneDriver,omitempty"`
	// DataplaneDriver filename of the external dataplane driver to use.  Only used if UseInternalDataplaneDriver
	// is set to false.
	DataplaneDriver *string `json:"dataplaneDriver,omitempty"`
	// DataplaneWatchdogTimeout is the readiness/liveness timeout used for Felix's (internal) dataplane driver.
	// Deprecated: replaced by the generic HealthTimeoutOverrides.
	DataplaneWatchdogTimeout *v1.Duration `json:"dataplaneWatchdogTimeout,omitempty"`
	// IPv6Support controls whether Felix enables support for IPv6 (if supported by the in-use dataplane).
	IPv6Support *bool `json:"ipv6Support,omitempty"`
	// RouteRefreshInterval is the period at which Felix re-checks the routes
	// in the dataplane to ensure that no other process has accidentally broken Calico's rules.
	// Set to 0 to disable route refresh. [Default: 90s]
	RouteRefreshInterval *v1.Duration `json:"routeRefreshInterval,omitempty"`
	// InterfaceRefreshInterval is the period at which Felix rescans local interfaces to verify their state.
	// The rescan can be disabled by setting the interval to 0.
	InterfaceRefreshInterval *v1.Duration `json:"interfaceRefreshInterval,omitempty"`
	// IptablesRefreshInterval is the period at which Felix re-checks the IP sets
	// in the dataplane to ensure that no other process has accidentally broken Calico's rules.
	// Set to 0 to disable IP sets refresh. Note: the default for this value is lower than the
	// other refresh intervals as a workaround for a Linux kernel bug that was fixed in kernel
	// version 4.11. If you are using v4.11 or greater you may want to set this to, a higher value
	// to reduce Felix CPU usage. [Default: 10s]
	IptablesRefreshInterval *v1.Duration `json:"iptablesRefreshInterval,omitempty"`
	// IptablesPostWriteCheckInterval is the period after Felix has done a write
	// to the dataplane that it schedules an extra read back in order to check the write was not
	// clobbered by another process. This should only occur if another application on the system
	// doesn't respect the iptables lock. [Default: 1s]
	IptablesPostWriteCheckInterval *v1.Duration `json:"iptablesPostWriteCheckInterval,omitempty"`
	// IptablesLockProbeInterval configures the interval between attempts to claim
	// the xtables lock.  Shorter intervals are more responsive but use more CPU.  [Default: 50ms]
	IptablesLockProbeInterval *v1.Duration `json:"iptablesLockProbeInterval,omitempty"`
	// FeatureDetectOverride is used to override feature detection based on auto-detected platform
	// capabilities.  Values are specified in a comma separated list with no spaces, example;
	// "SNATFullyRandom=true,MASQFullyRandom=false,RestoreSupportsLock=". A value of "true" or "false" will
	// force enable/disable feature, empty or omitted values fall back to auto-detection.
	FeatureDetectOverride *string `json:"featureDetectOverride,omitempty"`
	// FeatureGates is used to enable or disable tech-preview Calico features.
	// Values are specified in a comma separated list with no spaces, example;
	// "BPFConnectTimeLoadBalancingWorkaround=enabled,XyZ=false". This is
	// used to enable features that are not fully production ready.
	FeatureGates *string `json:"featureGates,omitempty"`
	// IpsetsRefreshInterval controls the period at which Felix re-checks all IP sets to look for discrepancies.
	// Set to 0 to disable the periodic refresh. [Default: 90s]
	IpsetsRefreshInterval *v1.Duration `json:"ipsetsRefreshInterval,omitempty"`
	// MaxIpsetSize is the maximum number of IP addresses that can be stored in an IP set. Not applicable
	// if using the nftables backend.
	MaxIpsetSize *int `json:"maxIpsetSize,omitempty"`
	// IptablesBackend controls which backend of iptables will be used. The default is `Auto`.
	//
	// Warning: changing this on a running system can leave "orphaned" rules in the "other" backend. These
	// should be cleaned up to avoid confusing interactions.
	IptablesBackend *projectcalicov3.IptablesBackend `json:"iptablesBackend,omitempty"`
	// XDPRefreshInterval is the period at which Felix re-checks all XDP state to ensure that no
	// other process has accidentally broken Calico's BPF maps or attached programs. Set to 0 to
	// disable XDP refresh. [Default: 90s]
	XDPRefreshInterval *v1.Duration `json:"xdpRefreshInterval,omitempty"`
	// NetlinkTimeout is the timeout when talking to the kernel over the netlink protocol, used for programming
	// routes, rules, and other kernel objects. [Default: 10s]
	NetlinkTimeout *v1.Duration `json:"netlinkTimeout,omitempty"`
	// MetadataAddr is the IP address or domain name of the server that can answer VM queries for
	// cloud-init metadata. In OpenStack, this corresponds to the machine running nova-api (or in
	// Ubuntu, nova-api-metadata). A value of none (case-insensitive) means that Felix should not
	// set up any NAT rule for the metadata path. [Default: 127.0.0.1]
	MetadataAddr *string `json:"metadataAddr,omitempty"`
	// MetadataPort is the port of the metadata server. This, combined with global.MetadataAddr (if
	// not 'None'), is used to set up a NAT rule, from 169.254.169.254:80 to MetadataAddr:MetadataPort.
	// In most cases this should not need to be changed [Default: 8775].
	MetadataPort *int `json:"metadataPort,omitempty"`
	// OpenstackRegion is the name of the region that a particular Felix belongs to. In a multi-region
	// Calico/OpenStack deployment, this must be configured somehow for each Felix (here in the datamodel,
	// or in felix.cfg or the environment on each compute node), and must match the [calico]
	// openstack_region value configured in neutron.conf on each node. [Default: Empty]
	OpenstackRegion *string `json:"openstackRegion,omitempty"`
	// InterfacePrefix is the interface name prefix that identifies workload endpoints and so distinguishes
	// them from host endpoint interfaces. Note: in environments other than bare metal, the orchestrators
	// configure this appropriately. For example our Kubernetes and Docker integrations set the 'cali' value,
	// and our OpenStack integration sets the 'tap' value. [Default: cali]
	InterfacePrefix *string `json:"interfacePrefix,omitempty"`
	// InterfaceExclude A comma-separated list of interface names that should be excluded when Felix is resolving
	// host endpoints. The default value ensures that Felix ignores Kubernetes' internal `kube-ipvs0` device. If you
	// want to exclude multiple interface names using a single value, the list supports regular expressions. For
	// regular expressions you must wrap the value with `/`. For example having values `/^kube/,veth1` will exclude
	// all interfaces that begin with `kube` and also the interface `veth1`. [Default: kube-ipvs0]
	InterfaceExclude *string `json:"interfaceExclude,omitempty"`
	// ChainInsertMode controls whether Felix hooks the kernel's top-level iptables chains by inserting a rule
	// at the top of the chain or by appending a rule at the bottom. insert is the safe default since it prevents
	// Calico's rules from being bypassed. If you switch to append mode, be sure that the other rules in the chains
	// signal acceptance by falling through to the Calico rules, otherwise the Calico policy will be bypassed.
	// [Default: insert]
	ChainInsertMode *string `json:"chainInsertMode,omitempty"`
	// DefaultEndpointToHostAction controls what happens to traffic that goes from a workload endpoint to the host
	// itself (after the endpoint's egress policy is applied). By default, Calico blocks traffic from workload
	// endpoints to the host itself with an iptables "DROP" action. If you want to allow some or all traffic from
	// endpoint to host, set this parameter to RETURN or ACCEPT. Use RETURN if you have your own rules in the iptables
	// "INPUT" chain; Calico will insert its rules at the top of that chain, then "RETURN" packets to the "INPUT" chain
	// once it has completed processing workload endpoint egress policy. Use ACCEPT to unconditionally accept packets
	// from workloads after processing workload endpoint egress policy. [Default: Drop]
	DefaultEndpointToHostAction *string `json:"defaultEndpointToHostAction,omitempty"`
	// IptablesFilterAllowAction controls what happens to traffic that is accepted by a Felix policy chain in the
	// iptables filter table (which is used for "normal" policy). The default will immediately `Accept` the traffic. Use
	// `Return` to send the traffic back up to the system chains for further processing.
	IptablesFilterAllowAction *string `json:"iptablesFilterAllowAction,omitempty"`
	// IptablesMangleAllowAction controls what happens to traffic that is accepted by a Felix policy chain in the
	// iptables mangle table (which is used for "pre-DNAT" policy). The default will immediately `Accept` the traffic.
	// Use `Return` to send the traffic back up to the system chains for further processing.
	IptablesMangleAllowAction *string `json:"iptablesMangleAllowAction,omitempty"`
	// IptablesFilterDenyAction controls what happens to traffic that is denied by network policy. By default Calico blocks traffic
	// with an iptables "DROP" action. If you want to use "REJECT" action instead you can configure it in here.
	IptablesFilterDenyAction *string `json:"iptablesFilterDenyAction,omitempty"`
	// LogPrefix is the log prefix that Felix uses when rendering LOG rules. It is possible to use the following specifiers
	// to include extra information in the log prefix.
	// - %t: Tier name.
	// - %k: Kind (short names).
	// - %n: Policy or profile name.
	// - %p: Policy or profile name (namespace/name for namespaced kinds or just name for non namespaced kinds).
	// Calico includes ": " characters at the end of the generated log prefix.
	// Note that iptables shows up to 29 characters for the log prefix and nftables up to 127 characters. Extra characters are truncated.
	// [Default: calico-packet]
	LogPrefix *string `json:"logPrefix,omitempty"`
	// LogActionRateLimit sets the rate of hitting a Log action. The value must be in the format "N/unit",
	// where N is a number and unit is one of: second, minute, hour, or day. For example: "10/second" or "100/hour".
	LogActionRateLimit *string `json:"logActionRateLimit,omitempty"`
	// LogActionRateLimitBurst sets the rate limit burst of hitting a Log action when LogActionRateLimit is enabled.
	LogActionRateLimitBurst *int `json:"logActionRateLimitBurst,omitempty"`
	// LogFilePath is the full path to the Felix log. Set to none to disable file logging. [Default: /var/log/calico/felix.log]
	LogFilePath *string `json:"logFilePath,omitempty"`
	// LogSeverityFile is the log severity above which logs are sent to the log file. [Default: Info]
	LogSeverityFile *string `json:"logSeverityFile,omitempty"`
	// LogSeverityScreen is the log severity above which logs are sent to the stdout. [Default: Info]
	LogSeverityScreen *string `json:"logSeverityScreen,omitempty"`
	// LogSeveritySys is the log severity above which logs are sent to the syslog. Set to None for no logging to syslog.
	// [Default: Info]
	LogSeveritySys *string `json:"logSeveritySys,omitempty"`
	// LogDebugFilenameRegex controls which source code files have their Debug log output included in the logs.
	// Only logs from files with names that match the given regular expression are included.  The filter only applies
	// to Debug level logs.
	LogDebugFilenameRegex *string `json:"logDebugFilenameRegex,omitempty"`
	// IPIPEnabled overrides whether Felix should configure an IPIP interface on the host. Optional as Felix
	// determines this based on the existing IP pools. [Default: nil (unset)]
	IPIPEnabled *bool `json:"ipipEnabled,omitempty"`
	// IPIPMTU controls the MTU to set on the IPIP tunnel device.  Optional as Felix auto-detects the MTU based on the
	// MTU of the host's interfaces. [Default: 0 (auto-detect)]
	IPIPMTU *int `json:"ipipMTU,omitempty"`
	// VXLANEnabled overrides whether Felix should create the VXLAN tunnel device for IPv4 VXLAN networking.
	// Optional as Felix determines this based on the existing IP pools. [Default: nil (unset)]
	VXLANEnabled *bool `json:"vxlanEnabled,omitempty"`
	// VXLANMTU is the MTU to set on the IPv4 VXLAN tunnel device.  Optional as Felix auto-detects the MTU based on the
	// MTU of the host's interfaces. [Default: 0 (auto-detect)]
	VXLANMTU *int `json:"vxlanMTU,omitempty"`
	// VXLANMTUV6 is the MTU to set on the IPv6 VXLAN tunnel device. Optional as Felix auto-detects the MTU based on the
	// MTU of the host's interfaces. [Default: 0 (auto-detect)]
	VXLANMTUV6 *int `json:"vxlanMTUV6,omitempty"`
	// VXLANPort is the UDP port number to use for VXLAN traffic. [Default: 4789]
	VXLANPort *int `json:"vxlanPort,omitempty"`
	// VXLANVNI is the VXLAN VNI to use for VXLAN traffic.  You may need to change this if the default value is
	// in use on your system. [Default: 4096]
	VXLANVNI *int `json:"vxlanVNI,omitempty"`
	// AllowVXLANPacketsFromWorkloads controls whether Felix will add a rule to drop VXLAN encapsulated traffic
	// from workloads. [Default: false]
	AllowVXLANPacketsFromWorkloads *bool `json:"allowVXLANPacketsFromWorkloads,omitempty"`
	// AllowIPIPPacketsFromWorkloads controls whether Felix will add a rule to drop IPIP encapsulated traffic
	// from workloads. [Default: false]
	AllowIPIPPacketsFromWorkloads *bool `json:"allowIPIPPacketsFromWorkloads,omitempty"`
	// ReportingInterval is the interval at which Felix reports its status into the datastore or 0 to disable.
	// Must be non-zero in OpenStack deployments. [Default: 30s]
	ReportingInterval *v1.Duration `json:"reportingInterval,omitempty"`
	// ReportingTTL is the time-to-live setting for process-wide status reports. [Default: 90s]
	ReportingTTL *v1.Duration `json:"reportingTTL,omitempty"`
	// EndpointReportingEnabled controls whether Felix reports endpoint status to the datastore. This is only used
	// by the OpenStack integration. [Default: false]
	EndpointReportingEnabled *bool `json:"endpointReportingEnabled,omitempty"`
	// EndpointReportingDelay is the delay before Felix reports endpoint status to the datastore. This is only used
	// by the OpenStack integration. [Default: 1s]
	EndpointReportingDelay *v1.Duration `json:"endpointReportingDelay,omitempty"`
	// EndpointStatusPathPrefix is the path to the directory where endpoint status will be written. Endpoint status
	// file reporting is disabled if field is left empty.
	//
	// Chosen directory should match the directory used by the CNI plugin for PodStartupDelay.
	// [Default: /var/run/calico]
	EndpointStatusPathPrefix *string `json:"endpointStatusPathPrefix,omitempty"`
	// IptablesMarkMask is the mask that Felix selects its IPTables Mark bits from. Should be a 32 bit hexadecimal
	// number with at least 8 bits set, none of which clash with any other mark bits in use on the system.
	// [Default: 0xffff0000]
	IptablesMarkMask *uint32 `json:"iptablesMarkMask,omitempty"`
	// DisableConntrackInvalidCheck disables the check for invalid connections in conntrack. While the conntrack
	// invalid check helps to detect malicious traffic, it can also cause issues with certain multi-NIC scenarios.
	DisableConntrackInvalidCheck *bool `json:"disableConntrackInvalidCheck,omitempty"`
	// HealthEnabled if set to true, enables Felix's health port, which provides readiness and liveness endpoints.
	// [Default: false]
	HealthEnabled *bool `json:"healthEnabled,omitempty"`
	// HealthHost is the host that the health server should bind to. [Default: localhost]
	HealthHost *string `json:"healthHost,omitempty"`
	// HealthPort is the TCP port that the health server should bind to. [Default: 9099]
	HealthPort *int `json:"healthPort,omitempty"`
	// HealthTimeoutOverrides allows the internal watchdog timeouts of individual subcomponents to be
	// overridden.  This is useful for working around "false positive" liveness timeouts that can occur
	// in particularly stressful workloads or if CPU is constrained.  For a list of active
	// subcomponents, see Felix's logs.
	HealthTimeoutOverrides []HealthTimeoutOverrideApplyConfiguration `json:"healthTimeoutOverrides,omitempty"`
	// PrometheusMetricsEnabled enables the Prometheus metrics server in Felix if set to true. [Default: false]
	PrometheusMetricsEnabled *bool `json:"prometheusMetricsEnabled,omitempty"`
	// PrometheusMetricsHost is the host that the Prometheus metrics server should bind to. [Default: empty]
	PrometheusMetricsHost *string `json:"prometheusMetricsHost,omitempty"`
	// PrometheusMetricsPort is the TCP port that the Prometheus metrics server should bind to. [Default: 9091]
	PrometheusMetricsPort *int `json:"prometheusMetricsPort,omitempty"`
	// PrometheusGoMetricsEnabled disables Go runtime metrics collection, which the Prometheus client does by default, when
	// set to false. This reduces the number of metrics reported, reducing Prometheus load. [Default: true]
	PrometheusGoMetricsEnabled *bool `json:"prometheusGoMetricsEnabled,omitempty"`
	// PrometheusProcessMetricsEnabled disables process metrics collection, which the Prometheus client does by default, when
	// set to false. This reduces the number of metrics reported, reducing Prometheus load. [Default: true]
	PrometheusProcessMetricsEnabled *bool `json:"prometheusProcessMetricsEnabled,omitempty"`
	// PrometheusWireGuardMetricsEnabled disables wireguard metrics collection, which the Prometheus client does by default, when
	// set to false. This reduces the number of metrics reported, reducing Prometheus load. [Default: true]
	PrometheusWireGuardMetricsEnabled *bool `json:"prometheusWireGuardMetricsEnabled,omitempty"`
	// PrometheusMetricsCAFile defines the absolute path to the TLS CA certificate file used for securing the /metrics endpoint.
	// This certificate must be valid and accessible by the calico-node process.
	PrometheusMetricsCAFile *string `json:"prometheusMetricsCAFile,omitempty"`
	// PrometheusMetricsCertFile defines the absolute path to the TLS certificate file used for securing the /metrics endpoint.
	// This certificate must be valid and accessible by the calico-node process.
	PrometheusMetricsCertFile *string `json:"prometheusMetricsCertFile,omitempty"`
	// PrometheusMetricsKeyFile defines the absolute path to the private key file corresponding to the TLS certificate
	// used for securing the /metrics endpoint. The private key must be valid and accessible by the calico-node process.
	PrometheusMetricsKeyFile *string `json:"prometheusMetricsKeyFile,omitempty"`
	// PrometheusMetricsClientAuth specifies the client authentication type for the /metrics endpoint.
	// This determines how the server validates client certificates. Default is "RequireAndVerifyClientCert".
	PrometheusMetricsClientAuth *projectcalicov3.PrometheusMetricsClientAuthType `json:"prometheusMetricsClientAuth,omitempty"`
	// FailsafeInboundHostPorts is a list of ProtoPort struct objects including UDP/TCP/SCTP ports and CIDRs that Felix will
	// allow incoming traffic to host endpoints on irrespective of the security policy. This is useful to avoid accidentally
	// cutting off a host with incorrect configuration. For backwards compatibility, if the protocol is not specified,
	// it defaults to "tcp". If a CIDR is not specified, it will allow traffic from all addresses. To disable all inbound host ports,
	// use the value "[]". The default value allows ssh access, DHCP, BGP, etcd and the Kubernetes API.
	// [Default: tcp:22, udp:68, tcp:179, tcp:2379, tcp:2380, tcp:5473, tcp:6443, tcp:6666, tcp:6667 ]
	FailsafeInboundHostPorts *[]ProtoPortApplyConfiguration `json:"failsafeInboundHostPorts,omitempty"`
	// FailsafeOutboundHostPorts is a list of PortProto struct objects including UDP/TCP/SCTP ports and CIDRs that Felix
	// will allow outgoing traffic from host endpoints to irrespective of the security policy. This is useful to avoid accidentally
	// cutting off a host with incorrect configuration. For backwards compatibility, if the protocol is not specified, it defaults
	// to "tcp". If a CIDR is not specified, it will allow traffic from all addresses. To disable all outbound host ports,
	// use the value "[]". The default value opens etcd's standard ports to ensure that Felix does not get cut off from etcd
	// as well as allowing DHCP, DNS, BGP and the Kubernetes API.
	// [Default: udp:53, udp:67, tcp:179, tcp:2379, tcp:2380, tcp:5473, tcp:6443, tcp:6666, tcp:6667 ]
	FailsafeOutboundHostPorts *[]ProtoPortApplyConfiguration `json:"failsafeOutboundHostPorts,omitempty"`
	// KubeNodePortRanges holds list of port ranges used for service node ports. Only used if felix detects kube-proxy running in ipvs mode.
	// Felix uses these ranges to separate host and workload traffic. [Default: 30000:32767].
	KubeNodePortRanges *[]numorstring.Port `json:"kubeNodePortRanges,omitempty"`
	// PolicySyncPathPrefix is used to by Felix to communicate policy changes to external services,
	// like Application layer policy. [Default: Empty]
	PolicySyncPathPrefix *string `json:"policySyncPathPrefix,omitempty"`
	// UsageReportingEnabled reports anonymous Calico version number and cluster size to projectcalico.org. Logs warnings returned by the usage
	// server. For example, if a significant security vulnerability has been discovered in the version of Calico being used. [Default: true]
	UsageReportingEnabled *bool `json:"usageReportingEnabled,omitempty"`
	// UsageReportingInitialDelay controls the minimum delay before Felix makes a report. [Default: 300s]
	UsageReportingInitialDelay *v1.Duration `json:"usageReportingInitialDelay,omitempty"`
	// UsageReportingInterval controls the interval at which Felix makes reports. [Default: 86400s]
	UsageReportingInterval *v1.Duration `json:"usageReportingInterval,omitempty"`
	// NATPortRange specifies the range of ports that is used for port mapping when doing outgoing NAT. When unset the default behavior of the
	// network stack is used.
	NATPortRange *numorstring.Port `json:"natPortRange,omitempty"`
	// NATOutgoingAddress specifies an address to use when performing source NAT for traffic in a natOutgoing pool that
	// is leaving the network. By default the address used is an address on the interface the traffic is leaving on
	// (i.e. it uses the iptables MASQUERADE target).
	NATOutgoingAddress *string `json:"natOutgoingAddress,omitempty"`
	// When a IP pool setting `natOutgoing` is true, packets sent from Calico networked containers in this IP pool to destinations will be masqueraded.
	// Configure which type of destinations is excluded from being masqueraded.
	// - IPPoolsOnly: destinations outside of this IP pool will be masqueraded.
	// - IPPoolsAndHostIPs: destinations outside of this IP pool and all hosts will be masqueraded.
	// [Default: IPPoolsOnly]
	NATOutgoingExclusions *projectcalicov3.NATOutgoingExclusionsType `json:"natOutgoingExclusions,omitempty"`
	// DeviceRouteSourceAddress IPv4 address to set as the source hint for routes programmed by Felix. When not set
	// the source address for local traffic from host to workload will be determined by the kernel.
	DeviceRouteSourceAddress *string `json:"deviceRouteSourceAddress,omitempty"`
	// DeviceRouteSourceAddressIPv6 IPv6 address to set as the source hint for routes programmed by Felix. When not set
	// the source address for local traffic from host to workload will be determined by the kernel.
	DeviceRouteSourceAddressIPv6 *string `json:"deviceRouteSourceAddressIPv6,omitempty"`
	// DeviceRouteProtocol controls the protocol to set on routes programmed by Felix. The protocol is an 8-bit label
	// used to identify the owner of the route.
	DeviceRouteProtocol *int `json:"deviceRouteProtocol,omitempty"`
	// RemoveExternalRoutes Controls whether Felix will remove unexpected routes to workload interfaces. Felix will
	// always clean up expected routes that use the configured DeviceRouteProtocol.  To add your own routes, you must
	// use a distinct protocol (in addition to setting this field to false).
	RemoveExternalRoutes *bool `json:"removeExternalRoutes,omitempty"`
	// ProgramClusterRoutes controls how a cluster node gets a route to a workload on another node,
	// when that workload's IP comes from an IP Pool with vxlanMode: Never. When ProgramClusterRoutes is Disabled,
	// it is expected that confd and BIRD will program that route. When ProgramClusterRoutes is Enabled, Felix program that route.
	// Felix always programs such routes for IP Pools with vxlanMode: Always or vxlanMode: CrossSubnet. [Default: Disabled]
	ProgramClusterRoutes *string `json:"programClusterRoutes,omitempty"`
	// IPForwarding controls whether Felix sets the host sysctls to enable IP forwarding.  IP forwarding is required
	// when using Calico for workload networking.  This should be disabled only on hosts where Calico is used solely for
	// host protection. In BPF mode, due to a kernel interaction, either IPForwarding must be enabled or BPFEnforceRPF
	// must be disabled. [Default: Enabled]
	IPForwarding *string `json:"ipForwarding,omitempty"`
	// ExternalNodesCIDRList is a list of CIDR's of external, non-Calico nodes from which VXLAN/IPIP overlay traffic
	// will be allowed.  By default, external tunneled traffic is blocked to reduce attack surface.
	ExternalNodesCIDRList *[]string `json:"externalNodesList,omitempty"`
	// DebugMemoryProfilePath is the path to write the memory profile to when triggered by signal.
	DebugMemoryProfilePath *string `json:"debugMemoryProfilePath,omitempty"`
	// DebugDisableLogDropping disables the dropping of log messages when the log buffer is full.  This can
	// significantly impact performance if log write-out is a bottleneck. [Default: false]
	DebugDisableLogDropping *bool `json:"debugDisableLogDropping,omitempty"`
	// DebugSimulateCalcGraphHangAfter is used to simulate a hang in the calculation graph after the specified duration.
	// This is useful in tests of the watchdog system only!
	DebugSimulateCalcGraphHangAfter *v1.Duration `json:"debugSimulateCalcGraphHangAfter,omitempty"`
	// DebugSimulateDataplaneHangAfter is used to simulate a hang in the dataplane after the specified duration.
	// This is useful in tests of the watchdog system only!
	DebugSimulateDataplaneHangAfter *v1.Duration `json:"debugSimulateDataplaneHangAfter,omitempty"`
	// DebugSimulateDataplaneApplyDelay adds an artificial delay to every dataplane operation.  This is useful for
	// simulating a heavily loaded system for test purposes only.
	DebugSimulateDataplaneApplyDelay *v1.Duration `json:"debugSimulateDataplaneApplyDelay,omitempty"`
	// DebugHost is the host IP or hostname to bind the debug port to.  Only used
	// if DebugPort is set. [Default:localhost]
	DebugHost *string `json:"debugHost,omitempty"`
	// DebugPort if set, enables Felix's debug HTTP port, which allows memory and CPU profiles
	// to be retrieved.  The debug port is not secure, it should not be exposed to the internet.
	DebugPort *int `json:"debugPort,omitempty"`
	// This parameter can be used to limit the host interfaces on which Calico will apply SNAT to traffic leaving a
	// Calico IPAM pool with "NAT outgoing" enabled. This can be useful if you have a main data interface, where
	// traffic should be SNATted and a secondary device (such as the docker bridge) which is local to the host and
	// doesn't require SNAT. This parameter uses the iptables interface matching syntax, which allows + as a
	// wildcard. Most users will not need to set this. Example: if your data interfaces are eth0 and eth1 and you
	// want to exclude the docker bridge, you could set this to eth+
	IptablesNATOutgoingInterfaceFilter *string `json:"iptablesNATOutgoingInterfaceFilter,omitempty"`
	// SidecarAccelerationEnabled enables experimental sidecar acceleration [Default: false]
	SidecarAccelerationEnabled *bool `json:"sidecarAccelerationEnabled,omitempty"`
	// XDPEnabled enables XDP acceleration for suitable untracked incoming deny rules. [Default: true]
	XDPEnabled *bool `json:"xdpEnabled,omitempty"`
	// GenericXDPEnabled enables Generic XDP so network cards that don't support XDP offload or driver
	// modes can use XDP. This is not recommended since it doesn't provide better performance than
	// iptables. [Default: false]
	GenericXDPEnabled *bool `json:"genericXDPEnabled,omitempty"`
	// NFTablesMode configures nftables support in Felix. [Default: Auto]
	NFTablesMode *projectcalicov3.NFTablesMode `json:"nftablesMode,omitempty"`
	// NftablesRefreshInterval controls the interval at which Felix periodically refreshes the nftables rules. [Default: 90s]
	NftablesRefreshInterval *v1.Duration `json:"nftablesRefreshInterval,omitempty"`
	// NftablesFilterAllowAction controls the nftables action that Felix uses to represent the "allow" policy verdict
	// in the filter table. The default is to `ACCEPT` the traffic, which is a terminal action.  Alternatively,
	// `RETURN` can be used to return the traffic back to the top-level chain for further processing by your rules.
	NftablesFilterAllowAction *string `json:"nftablesFilterAllowAction,omitempty"`
	// NftablesMangleAllowAction controls the nftables action that Felix uses to represent the "allow" policy verdict
	// in the mangle table. The default is to `ACCEPT` the traffic, which is a terminal action.  Alternatively,
	// `RETURN` can be used to return the traffic back to the top-level chain for further processing by your rules.
	NftablesMangleAllowAction *string `json:"nftablesMangleAllowAction,omitempty"`
	// NftablesFilterDenyAction controls what happens to traffic that is denied by network policy. By default, Calico
	// blocks traffic with a "drop" action. If you want to use a "reject" action instead you can configure it here.
	NftablesFilterDenyAction *string `json:"nftablesFilterDenyAction,omitempty"`
	// NftablesMarkMask is the mask that Felix selects its nftables Mark bits from. Should be a 32 bit hexadecimal
	// number with at least 8 bits set, none of which clash with any other mark bits in use on the system.
	// [Default: 0xffff0000]
	NftablesMarkMask *uint32 `json:"nftablesMarkMask,omitempty"`
	// BPFEnabled, if enabled Felix will use the BPF dataplane. [Default: false]
	BPFEnabled *bool `json:"bpfEnabled,omitempty"`
	// BPFDisableUnprivileged, if enabled, Felix sets the kernel.unprivileged_bpf_disabled sysctl to disable
	// unprivileged use of BPF.  This ensures that unprivileged users cannot access Calico's BPF maps and
	// cannot insert their own BPF programs to interfere with Calico's. [Default: true]
	BPFDisableUnprivileged *bool `json:"bpfDisableUnprivileged,omitempty"`
	// BPFJITHardening controls BPF JIT hardening. When set to "Auto", Felix will set JIT hardening to 1
	// if it detects the current value is 2 (strict mode that hurts performance). When set to "Strict",
	// Felix will not modify the JIT hardening setting. [Default: Auto]
	BPFJITHardening *projectcalicov3.BPFJITHardeningType `json:"bpfJITHardening,omitempty"`
	// BPFLogLevel controls the log level of the BPF programs when in BPF dataplane mode.  One of "Off", "Info", or
	// "Debug".  The logs are emitted to the BPF trace pipe, accessible with the command `tc exec bpf debug`.
	// [Default: Off].
	BPFLogLevel *string `json:"bpfLogLevel,omitempty"`
	// BPFConntrackLogLevel controls the log level of the BPF conntrack cleanup program, which runs periodically
	// to clean up expired BPF conntrack entries.
	// [Default: Off].
	BPFConntrackLogLevel *string `json:"bpfConntrackLogLevel,omitempty"`
	// BPFConntrackCleanupMode controls how BPF conntrack entries are cleaned up.  `Auto` will use a BPF program if supported,
	// falling back to userspace if not.  `Userspace` will always use the userspace cleanup code.  `BPFProgram` will
	// always use the BPF program (failing if not supported).
	//
	// /To be deprecated in future versions as conntrack map type changed to
	// lru_hash and userspace cleanup is the only mode that is supported.
	// [Default: Userspace]
	BPFConntrackCleanupMode *projectcalicov3.BPFConntrackMode `json:"bpfConntrackMode,omitempty"`
	// BPFConntrackTimers overrides the default values for the specified conntrack timer if
	// set. Each value can be either a duration or `Auto` to pick the value from
	// a Linux conntrack timeout.
	//
	// Configurable timers are: CreationGracePeriod, TCPSynSent,
	// TCPEstablished, TCPFinsSeen, TCPResetSeen, UDPTimeout, GenericTimeout,
	// ICMPTimeout.
	//
	// Unset values are replaced by the default values with a warning log for
	// incorrect values.
	BPFConntrackTimeouts *BPFConntrackTimeoutsApplyConfiguration `json:"bpfConntrackTimeouts,omitempty"`
	// BPFLogFilters is a map of key=values where the value is
	// a pcap filter expression and the key is an interface name with 'all'
	// denoting all interfaces, 'weps' all workload endpoints and 'heps' all host
	// endpoints.
	//
	// When specified as an env var, it accepts a comma-separated list of
	// key=values.
	// [Default: unset - means all debug logs are emitted]
	BPFLogFilters *map[string]string `json:"bpfLogFilters,omitempty"`
	// BPFCTLBLogFilter specifies, what is logged by connect time load balancer when BPFLogLevel is
	// debug. Currently has to be specified as 'all' when BPFLogFilters is set
	// to see CTLB logs.
	// [Default: unset - means logs are emitted when BPFLogLevel id debug and BPFLogFilters not set.]
	BPFCTLBLogFilter *string `json:"bpfCTLBLogFilter,omitempty"`
	// BPFDataIfacePattern is a regular expression that controls which interfaces Felix should attach BPF programs to
	// in order to catch traffic to/from the network.  This needs to match the interfaces that Calico workload traffic
	// flows over as well as any interfaces that handle incoming traffic to nodeports and services from outside the
	// cluster.  It should not match the workload interfaces (usually named cali...) or any other special device managed
	// by Calico itself (e.g., tunnels).
	BPFDataIfacePattern *string `json:"bpfDataIfacePattern,omitempty"`
	// BPFL3IfacePattern is a regular expression that allows to list tunnel devices like wireguard or vxlan (i.e., L3 devices)
	// in addition to BPFDataIfacePattern. That is, tunnel interfaces not created by Calico, that Calico workload traffic flows
	// over as well as any interfaces that handle incoming traffic to nodeports and services from outside the cluster.
	BPFL3IfacePattern *string `json:"bpfL3IfacePattern,omitempty"`
	// BPFConnectTimeLoadBalancingEnabled when in BPF mode, controls whether Felix installs the connection-time load
	// balancer.  The connect-time load balancer is required for the host to be able to reach Kubernetes services
	// and it improves the performance of pod-to-service connections.  The only reason to disable it is for debugging
	// purposes.
	//
	// Deprecated: Use BPFConnectTimeLoadBalancing [Default: true]
	BPFConnectTimeLoadBalancingEnabled *bool `json:"bpfConnectTimeLoadBalancingEnabled,omitempty"`
	// BPFConnectTimeLoadBalancing when in BPF mode, controls whether Felix installs the connect-time load
	// balancer. The connect-time load balancer is required for the host to be able to reach Kubernetes services
	// and it improves the performance of pod-to-service connections.When set to TCP, connect time load balancing
	// is available only for services with TCP ports. [Default: TCP]
	BPFConnectTimeLoadBalancing *projectcalicov3.BPFConnectTimeLBType `json:"bpfConnectTimeLoadBalancing,omitempty"`
	// BPFHostNetworkedNATWithoutCTLB when in BPF mode, controls whether Felix does a NAT without CTLB. This along with BPFConnectTimeLoadBalancing
	// determines the CTLB behavior. [Default: Enabled]
	BPFHostNetworkedNATWithoutCTLB *projectcalicov3.BPFHostNetworkedNATType `json:"bpfHostNetworkedNATWithoutCTLB,omitempty"`
	// BPFExternalServiceMode in BPF mode, controls how connections from outside the cluster to services (node ports
	// and cluster IPs) are forwarded to remote workloads.  If set to "Tunnel" then both request and response traffic
	// is tunneled to the remote node.  If set to "DSR", the request traffic is tunneled but the response traffic
	// is sent directly from the remote node.  In "DSR" mode, the remote node appears to use the IP of the ingress
	// node; this requires a permissive L2 network.  [Default: Tunnel]
	BPFExternalServiceMode *string `json:"bpfExternalServiceMode,omitempty"`
	// BPFDSROptoutCIDRs is a list of CIDRs which are excluded from DSR. That is, clients
	// in those CIDRs will access service node ports as if BPFExternalServiceMode was set to
	// Tunnel.
	BPFDSROptoutCIDRs *[]string `json:"bpfDSROptoutCIDRs,omitempty"`
	// BPFExtToServiceConnmark in BPF mode, controls a 32bit mark that is set on connections from an
	// external client to a local service. This mark allows us to control how packets of that
	// connection are routed within the host and how is routing interpreted by RPF check. [Default: 0]
	BPFExtToServiceConnmark *int `json:"bpfExtToServiceConnmark,omitempty"`
	// BPFKubeProxyIptablesCleanupEnabled, if enabled in BPF mode, Felix will proactively clean up the upstream
	// Kubernetes kube-proxy's iptables chains.  Should only be enabled if kube-proxy is not running.  [Default: true]
	BPFKubeProxyIptablesCleanupEnabled *bool `json:"bpfKubeProxyIptablesCleanupEnabled,omitempty"`
	// BPFKubeProxyMinSyncPeriod, in BPF mode, controls the minimum time between updates to the dataplane for Felix's
	// embedded kube-proxy.  Lower values give reduced set-up latency.  Higher values reduce Felix CPU usage by
	// batching up more work.  [Default: 1s]
	BPFKubeProxyMinSyncPeriod *v1.Duration `json:"bpfKubeProxyMinSyncPeriod,omitempty"`
	// BPFKubeProxyHealthzPort, in BPF mode, controls the port that Felix's embedded kube-proxy health check server binds to.
	// The health check server is used by external load balancers to determine if this node should receive traffic.
	// Set to 0 to disable the health check server.  [Default: 10256]
	BPFKubeProxyHealthzPort *int `json:"bpfKubeProxyHealthzPort,omitempty"`
	// BPFPSNATPorts sets the range from which we randomly pick a port if there is a source port
	// collision. This should be within the ephemeral range as defined by RFC 6056 (1024–65535) and
	// preferably outside the  ephemeral ranges used by common operating systems. Linux uses
	// 32768–60999, while others mostly use the IANA defined range 49152–65535. It is not necessarily
	// a problem if this range overlaps with the operating systems. Both ends of the range are
	// inclusive. [Default: 20000:29999]
	BPFPSNATPorts *numorstring.Port `json:"bpfPSNATPorts,omitempty"`
	// BPFMapSizeNATFrontend sets the size for NAT front end map.
	// FrontendMap should be large enough to hold an entry for each nodeport,
	// external IP and each port in each service.
	BPFMapSizeNATFrontend *int `json:"bpfMapSizeNATFrontend,omitempty"`
	// BPFMapSizeNATBackend sets the size for NAT back end map.
	// This is the total number of endpoints. This is mostly
	// more than the size of the number of services.
	BPFMapSizeNATBackend *int `json:"bpfMapSizeNATBackend,omitempty"`
	// BPFMapSizeNATAffinity sets the size of the BPF map that stores the affinity of a connection (for services that
	// enable that feature.
	BPFMapSizeNATAffinity *int `json:"bpfMapSizeNATAffinity,omitempty"`
	// BPFMapSizeRoute sets the size for the routes map.  The routes map should be large enough
	// to hold one entry per workload and a handful of entries per host (enough to cover its own IPs and
	// tunnel IPs).
	BPFMapSizeRoute *int `json:"bpfMapSizeRoute,omitempty"`
	// BPFMapSizeConntrack sets the size for the conntrack map.  This map must be large enough to hold
	// an entry for each active connection.  Warning: changing the size of the conntrack map can cause disruption.
	BPFMapSizeConntrack *int `json:"bpfMapSizeConntrack,omitempty"`
	// BPFMapSizePerCPUConntrack determines the size of conntrack map based on the number of CPUs. If set to a
	// non-zero value, overrides BPFMapSizeConntrack with `BPFMapSizePerCPUConntrack * (Number of CPUs)`.
	// This map must be large enough to hold an entry for each active connection.  Warning: changing the size of the
	// conntrack map can cause disruption.
	BPFMapSizePerCPUConntrack *int `json:"bpfMapSizePerCpuConntrack,omitempty"`
	// BPFMapSizeConntrackScaling controls whether and how we scale the conntrack map size depending
	// on its usage. 'Disabled' make the size stay at the default or whatever is set by
	// BPFMapSizeConntrack*. 'DoubleIfFull' doubles the size when the map is pretty much full even
	// after cleanups. [Default: DoubleIfFull]
	BPFMapSizeConntrackScaling *string `json:"bpfMapSizeConntrackScaling,omitempty"`
	// BPFMapSizeConntrackCleanupQueue sets the size for the map used to hold NAT conntrack entries that are queued
	// for cleanup.  This should be big enough to hold all the NAT entries that expire within one cleanup interval.
	BPFMapSizeConntrackCleanupQueue *int `json:"bpfMapSizeConntrackCleanupQueue,omitempty"`
	// BPFMapSizeIPSets sets the size for ipsets map.  The IP sets map must be large enough to hold an entry
	// for each endpoint matched by every selector in the source/destination matches in network policy.  Selectors
	// such as "all()" can result in large numbers of entries (one entry per endpoint in that case).
	BPFMapSizeIPSets *int `json:"bpfMapSizeIPSets,omitempty"`
	// BPFMapSizeIfState sets the size for ifstate map.  The ifstate map must be large enough to hold an entry
	// for each device (host + workloads) on a host.
	BPFMapSizeIfState *int `json:"bpfMapSizeIfState,omitempty"`
	// BPFHostConntrackBypass Controls whether to bypass Linux conntrack in BPF mode for
	// workloads and services. [Default: true - bypass Linux conntrack]
	BPFHostConntrackBypass *bool `json:"bpfHostConntrackBypass,omitempty"`
	// BPFEnforceRPF enforce strict RPF on all host interfaces with BPF programs regardless of
	// what is the per-interfaces or global setting. Possible values are Disabled, Strict
	// or Loose. [Default: Loose]
	BPFEnforceRPF *string `json:"bpfEnforceRPF,omitempty"`
	// BPFPolicyDebugEnabled when true, Felix records detailed information
	// about the BPF policy programs, which can be examined with the calico-bpf command-line tool.
	BPFPolicyDebugEnabled *bool `json:"bpfPolicyDebugEnabled,omitempty"`
	// BPFForceTrackPacketsFromIfaces in BPF mode, forces traffic from these interfaces
	// to skip Calico's iptables NOTRACK rule, allowing traffic from those interfaces to be
	// tracked by Linux conntrack.  Should only be used for interfaces that are not used for
	// the Calico fabric.  For example, a docker bridge device for non-Calico-networked
	// containers. [Default: docker+]
	BPFForceTrackPacketsFromIfaces *[]string `json:"bpfForceTrackPacketsFromIfaces,omitempty"`
	// BPFDisableGROForIfaces is a regular expression that controls which interfaces Felix should disable the
	// Generic Receive Offload [GRO] option.  It should not match the workload interfaces (usually named cali...).
	BPFDisableGROForIfaces *string `json:"bpfDisableGROForIfaces,omitempty"`
	// BPFExcludeCIDRsFromNAT is a list of CIDRs that are to be excluded from NAT
	// resolution so that host can handle them. A typical usecase is node local
	// DNS cache.
	BPFExcludeCIDRsFromNAT *[]string `json:"bpfExcludeCIDRsFromNAT,omitempty"`
	// BPFExportBufferSizeMB in BPF mode, controls the buffer size used for sending BPF events to felix.
	// [Default: 1]
	BPFExportBufferSizeMB *int `json:"bpfExportBufferSizeMB,omitempty"`
	// IstioAmbientMode configures Felix to work together with Tigera's Istio distribution.
	// [Default: Disabled]
	IstioAmbientMode *projectcalicov3.IstioAmbientMode `json:"istioAmbientMode,omitempty"`
	// IstioDSCPMark sets the value to use when directing traffic to Istio ZTunnel, when Istio is enabled. The mark is set only on
	// SYN packets at the final hop to avoid interference with other protocols. This value is reserved by Calico and must not be used
	// with other Istio installation. [Default: 23]
	IstioDSCPMark *numorstring.DSCP `json:"istioDSCPMark,omitempty"`
	// CgroupV2Path overrides the default location where to find the cgroup hierarchy.
	CgroupV2Path *string `json:"cgroupV2Path,omitempty"`
	// Continuous - Felix evaluates active flows on a regular basis to determine the rule
	// traces in the flow logs. Any policy updates that impact a flow will be reflected in the
	// pending_policies field, offering a near-real-time view of policy changes across flows.
	// None - Felix stops evaluating pending traces.
	// [Default: Continuous]
	FlowLogsPolicyEvaluationMode *projectcalicov3.FlowLogsPolicyEvaluationModeType `json:"flowLogsPolicyEvaluationMode,omitempty"`
	// BPFRedirectToPeer controls whether traffic may be forwarded directly to the peer side of a workload’s device.
	// Note that the legacy "L2Only" option is now deprecated and if set it is treated like "Enabled.
	// Setting this option to "Enabled" allows direct redirection (including from L3 host devices such as IPIP tunnels or WireGuard),
	// which can improve redirection performance but causes the redirected packets to bypass the host‑side ingress path.
	// As a result, packet‑capture tools on the host side of the workload device (for example, tcpdump) will not see that traffic. [Default: Enabled]
	BPFRedirectToPeer *string `json:"bpfRedirectToPeer,omitempty"`
	// BPFAttachType controls how are the BPF programs at the network interfaces attached.
	// By default `TCX` is used where available to enable easier coexistence with 3rd party programs.
	// `TC` can force the legacy method of attaching via a qdisc. `TCX` falls back to `TC` if `TCX` is not available.
	// [Default: TCX]
	BPFAttachType *projectcalicov3.BPFAttachOption `json:"bpfAttachType,omitempty"`
	// FlowLogsFlushInterval configures the interval at which Felix exports flow logs.
	FlowLogsFlushInterval *v1.Duration `json:"flowLogsFlushInterval,omitempty"`
	// When FlowLogsCollectorDebugTrace is set to true, enables the logs in the collector to be
	// printed in their entirety.
	FlowLogsCollectorDebugTrace *bool `json:"flowLogsCollectorDebugTrace,omitempty"`
	// FlowLogGoldmaneServer is the flow server endpoint to which flow data should be published.
	FlowLogsGoldmaneServer *string `json:"flowLogsGoldmaneServer,omitempty"`
	// FlowLogsLocalReporter configures local unix socket for reporting flow data from each node. [Default: Disabled]
	FlowLogsLocalReporter *string `json:"flowLogsLocalReporter,omitempty"`
	// BPFProfiling controls profiling of BPF programs. At the monent, it can be
	// Disabled or Enabled. [Default: Disabled]
	BPFProfiling *string `json:"bpfProfiling,omitempty"`
	// RouteSource configures where Felix gets its routing information.
	// - WorkloadIPs: use workload endpoints to construct routes.
	// - CalicoIPAM: the default - use IPAM data to construct routes.
	RouteSource *string `json:"routeSource,omitempty"`
	// Calico programs additional Linux route tables for various purposes.
	// RouteTableRanges specifies a set of table index ranges that Calico should use.
	// Deprecates`RouteTableRange`, overrides `RouteTableRange`.
	RouteTableRanges *projectcalicov3.RouteTableRanges `json:"routeTableRanges,omitempty"`
	// Deprecated in favor of RouteTableRanges.
	// Calico programs additional Linux route tables for various purposes.
	// RouteTableRange specifies the indices of the route tables that Calico should use.
	RouteTableRange *RouteTableRangeApplyConfiguration `json:"routeTableRange,omitempty"`
	// RouteSyncDisabled will disable all operations performed on the route table. Set to true to
	// run in network-policy mode only.
	RouteSyncDisabled *bool `json:"routeSyncDisabled,omitempty"`
	// Route Priority value for a normal priority Calico-programmed IPv4 route.  Note, higher
	// values mean lower priority. [Default: 1024]
	IPv4NormalRoutePriority *int `json:"ipv4NormalRoutePriority,omitempty"`
	// Route Priority value for an elevated priority Calico-programmed IPv4 route.  Note, higher
	// values mean lower priority.  Elevated priority is used during VM live migration, and for
	// optimal behaviour IPv4ElevatedRoutePriority must be less than IPv4NormalRoutePriority
	// [Default: 512]
	IPv4ElevatedRoutePriority *int `json:"ipv4ElevatedRoutePriority,omitempty"`
	// Route Priority value for a normal priority Calico-programmed IPv6 route.  Note, higher
	// values mean lower priority. [Default: 1024]
	IPv6NormalRoutePriority *int `json:"ipv6NormalRoutePriority,omitempty"`
	// Route Priority value for an elevated priority Calico-programmed IPv6 route.  Note, higher
	// values mean lower priority.  Elevated priority is used during VM live migration, and for
	// optimal behaviour IPv6ElevatedRoutePriority must be less than IPv6NormalRoutePriority
	// [Default: 512]
	IPv6ElevatedRoutePriority *int `json:"ipv6ElevatedRoutePriority,omitempty"`
	// LiveMigrationRouteConvergenceTime is the time to keep elevated route priority after a
	// VM live migration completes.  This allows routes to converge across the cluster before
	// reverting to normal priority. [Default: 30s]
	LiveMigrationRouteConvergenceTime *v1.Duration `json:"liveMigrationRouteConvergenceTime,omitempty"`
	// WireguardEnabled controls whether Wireguard is enabled for IPv4 (encapsulating IPv4 traffic over an IPv4 underlay network). [Default: false]
	WireguardEnabled *bool `json:"wireguardEnabled,omitempty"`
	// WireguardEnabledV6 controls whether Wireguard is enabled for IPv6 (encapsulating IPv6 traffic over an IPv6 underlay network). [Default: false]
	WireguardEnabledV6 *bool `json:"wireguardEnabledV6,omitempty"`
	// WireguardThreadingEnabled controls whether Wireguard has Threaded NAPI enabled. [Default: false]
	// This increases the maximum number of packets a Wireguard interface can process.
	// Consider threaded NAPI only if you have high packets per second workloads that are causing dropping packets due to a saturated `softirq` CPU core.
	// There is a [known issue](https://lore.kernel.org/netdev/CALrw=nEoT2emQ0OAYCjM1d_6Xe_kNLSZ6dhjb5FxrLFYh4kozA@mail.gmail.com/T/) with this setting
	// that may cause NAPI to get stuck holding the global `rtnl_mutex` when a peer is removed.
	// Workaround: Make sure your Linux kernel [includes this patch](https://github.com/torvalds/linux/commit/56364c910691f6d10ba88c964c9041b9ab777bd6) to unwedge NAPI.
	WireguardThreadingEnabled *bool `json:"wireguardThreadingEnabled,omitempty"`
	// WireguardListeningPort controls the listening port used by IPv4 Wireguard. [Default: 51820]
	WireguardListeningPort *int `json:"wireguardListeningPort,omitempty"`
	// WireguardListeningPortV6 controls the listening port used by IPv6 Wireguard. [Default: 51821]
	WireguardListeningPortV6 *int `json:"wireguardListeningPortV6,omitempty"`
	// WireguardRoutingRulePriority controls the priority value to use for the Wireguard routing rule. [Default: 99]
	WireguardRoutingRulePriority *int `json:"wireguardRoutingRulePriority,omitempty"`
	// WireguardInterfaceName specifies the name to use for the IPv4 Wireguard interface. [Default: wireguard.cali]
	WireguardInterfaceName *string `json:"wireguardInterfaceName,omitempty"`
	// WireguardInterfaceNameV6 specifies the name to use for the IPv6 Wireguard interface. [Default: wg-v6.cali]
	WireguardInterfaceNameV6 *string `json:"wireguardInterfaceNameV6,omitempty"`
	// WireguardMTU controls the MTU on the IPv4 Wireguard interface. See Configuring MTU [Default: 1440]
	WireguardMTU *int `json:"wireguardMTU,omitempty"`
	// WireguardMTUV6 controls the MTU on the IPv6 Wireguard interface. See Configuring MTU [Default: 1420]
	WireguardMTUV6 *int `json:"wireguardMTUV6,omitempty"`
	// WireguardHostEncryptionEnabled controls whether Wireguard host-to-host encryption is enabled. [Default: false]
	WireguardHostEncryptionEnabled *bool `json:"wireguardHostEncryptionEnabled,omitempty"`
	// WireguardPersistentKeepAlive controls Wireguard PersistentKeepalive option. Set 0 to disable. [Default: 0]
	WireguardPersistentKeepAlive *v1.Duration `json:"wireguardKeepAlive,omitempty"`
	// AWSSrcDstCheck controls whether Felix will try to change the "source/dest check" setting on the EC2 instance
	// on which it is running. A value of "Disable" will try to disable the source/dest check. Disabling the check
	// allows for sending workload traffic without encapsulation within the same AWS subnet.
	// [Default: DoNothing]
	AWSSrcDstCheck *projectcalicov3.AWSSrcDstCheckOption `json:"awsSrcDstCheck,omitempty"`
	// When service IP advertisement is enabled, prevent routing loops to service IPs that are
	// not in use, by dropping or rejecting packets that do not get DNAT'd by kube-proxy.
	// Unless set to "Disabled", in which case such routing loops continue to be allowed.
	// [Default: Drop]
	ServiceLoopPrevention *string `json:"serviceLoopPrevention,omitempty"`
	// WorkloadSourceSpoofing controls whether pods can use the allowedSourcePrefixes annotation to send traffic with a source IP
	// address that is not theirs. This is disabled by default. When set to "Any", pods can request any prefix.
	WorkloadSourceSpoofing *string `json:"workloadSourceSpoofing,omitempty"`
	// MTUIfacePattern is a regular expression that controls which interfaces Felix should scan in order
	// to calculate the host's MTU.
	// This should not match workload interfaces (usually named cali...).
	MTUIfacePattern *string `json:"mtuIfacePattern,omitempty"`
	// FloatingIPs configures whether or not Felix will program non-OpenStack floating IP addresses.  (OpenStack-derived
	// floating IPs are always programmed, regardless of this setting.)
	FloatingIPs *projectcalicov3.FloatingIPType `json:"floatingIPs,omitempty"`
	// WindowsManageFirewallRules configures whether or not Felix will program Windows Firewall rules (to allow inbound access to its own metrics ports). [Default: Disabled]
	WindowsManageFirewallRules *projectcalicov3.WindowsManageFirewallRulesMode `json:"windowsManageFirewallRules,omitempty"`
	// GoGCThreshold Sets the Go runtime's garbage collection threshold.  I.e. the percentage that the heap is
	// allowed to grow before garbage collection is triggered.  In general, doubling the value halves the CPU time
	// spent doing GC, but it also doubles peak GC memory overhead.  A special value of -1 can be used
	// to disable GC entirely; this should only be used in conjunction with the GoMemoryLimitMB setting.
	//
	// This setting is overridden by the GOGC environment variable.
	//
	// [Default: 40]
	GoGCThreshold *int `json:"goGCThreshold,omitempty"`
	// GoMemoryLimitMB sets a (soft) memory limit for the Go runtime in MB.  The Go runtime will try to keep its memory
	// usage under the limit by triggering GC as needed.  To avoid thrashing, it will exceed the limit if GC starts to
	// take more than 50% of the process's CPU time.  A value of -1 disables the memory limit.
	//
	// Note that the memory limit, if used, must be considerably less than any hard resource limit set at the container
	// or pod level.  This is because felix is not the only process that must run in the container or pod.
	//
	// This setting is overridden by the GOMEMLIMIT environment variable.
	//
	// [Default: -1]
	GoMemoryLimitMB *int `json:"goMemoryLimitMB,omitempty"`
	// GoMaxProcs sets the maximum number of CPUs that the Go runtime will use concurrently.  A value of -1 means
	// "use the system default"; typically the number of real CPUs on the system.
	//
	// this setting is overridden by the GOMAXPROCS environment variable.
	//
	// [Default: -1]
	GoMaxProcs *int `json:"goMaxProcs,omitempty"`
	// RequireMTUFile specifies whether mtu file is required to start the felix.
	// Optional as to keep the same as previous behavior. [Default: false]
	RequireMTUFile *bool `json:"requireMTUFile,omitempty"`
	// BPFMaglevMaxEndpointsPerService is the maximum number of endpoints
	// expected to be part of a single Maglev-enabled service.
	//
	// Influences the size of the per-service Maglev lookup-tables generated by Felix
	// and thus the amount of memory reserved.
	//
	// [Default: 100]
	BPFMaglevMaxEndpointsPerService *int `json:"bpfMaglevMaxEndpointsPerService,omitempty"`
	// BPFMaglevMaxServices is the maximum number of expected Maglev-enabled
	// services that Felix will allocate lookup-tables for.
	//
	// [Default: 100]
	BPFMaglevMaxServices *int `json:"bpfMaglevMaxServices,omitempty"`
}

// FelixConfigurationSpecApplyConfiguration constructs a declarative configuration of the FelixConfigurationSpec type for use with
// apply.
func FelixConfigurationSpec() *FelixConfigurationSpecApplyConfiguration {
	return &FelixConfigurationSpecApplyConfiguration{}
}

// WithNodeSelector sets the NodeSelector field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the NodeSelector field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithNodeSelector(value string) *FelixConfigurationSpecApplyConfiguration {
	b.NodeSelector = &value
	return b
}

// WithUseInternalDataplaneDriver sets the UseInternalDataplaneDriver field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the UseInternalDataplaneDriver field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithUseInternalDataplaneDriver(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.UseInternalDataplaneDriver = &value
	return b
}

// WithDataplaneDriver sets the DataplaneDriver field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the DataplaneDriver field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithDataplaneDriver(value string) *FelixConfigurationSpecApplyConfiguration {
	b.DataplaneDriver = &value
	return b
}

// WithDataplaneWatchdogTimeout sets the DataplaneWatchdogTimeout field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the DataplaneWatchdogTimeout field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithDataplaneWatchdogTimeout(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.DataplaneWatchdogTimeout = &value
	return b
}

// WithIPv6Support sets the IPv6Support field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IPv6Support field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIPv6Support(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.IPv6Support = &value
	return b
}

// WithRouteRefreshInterval sets the RouteRefreshInterval field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the RouteRefreshInterval field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithRouteRefreshInterval(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.RouteRefreshInterval = &value
	return b
}

// WithInterfaceRefreshInterval sets the InterfaceRefreshInterval field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the InterfaceRefreshInterval field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithInterfaceRefreshInterval(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.InterfaceRefreshInterval = &value
	return b
}

// WithIptablesRefreshInterval sets the IptablesRefreshInterval field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IptablesRefreshInterval field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIptablesRefreshInterval(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.IptablesRefreshInterval = &value
	return b
}

// WithIptablesPostWriteCheckInterval sets the IptablesPostWriteCheckInterval field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IptablesPostWriteCheckInterval field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIptablesPostWriteCheckInterval(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.IptablesPostWriteCheckInterval = &value
	return b
}

// WithIptablesLockProbeInterval sets the IptablesLockProbeInterval field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IptablesLockProbeInterval field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIptablesLockProbeInterval(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.IptablesLockProbeInterval = &value
	return b
}

// WithFeatureDetectOverride sets the FeatureDetectOverride field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the FeatureDetectOverride field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithFeatureDetectOverride(value string) *FelixConfigurationSpecApplyConfiguration {
	b.FeatureDetectOverride = &value
	return b
}

// WithFeatureGates sets the FeatureGates field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the FeatureGates field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithFeatureGates(value string) *FelixConfigurationSpecApplyConfiguration {
	b.FeatureGates = &value
	return b
}

// WithIpsetsRefreshInterval sets the IpsetsRefreshInterval field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IpsetsRefreshInterval field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIpsetsRefreshInterval(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.IpsetsRefreshInterval = &value
	return b
}

// WithMaxIpsetSize sets the MaxIpsetSize field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the MaxIpsetSize field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithMaxIpsetSize(value int) *FelixConfigurationSpecApplyConfiguration {
	b.MaxIpsetSize = &value
	return b
}

// WithIptablesBackend sets the IptablesBackend field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IptablesBackend field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIptablesBackend(value projectcalicov3.IptablesBackend) *FelixConfigurationSpecApplyConfiguration {
	b.IptablesBackend = &value
	return b
}

// WithXDPRefreshInterval sets the XDPRefreshInterval field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the XDPRefreshInterval field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithXDPRefreshInterval(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.XDPRefreshInterval = &value
	return b
}

// WithNetlinkTimeout sets the NetlinkTimeout field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the NetlinkTimeout field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithNetlinkTimeout(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.NetlinkTimeout = &value
	return b
}

// WithMetadataAddr sets the MetadataAddr field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the MetadataAddr field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithMetadataAddr(value string) *FelixConfigurationSpecApplyConfiguration {
	b.MetadataAddr = &value
	return b
}

// WithMetadataPort sets the MetadataPort field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the MetadataPort field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithMetadataPort(value int) *FelixConfigurationSpecApplyConfiguration {
	b.MetadataPort = &value
	return b
}

// WithOpenstackRegion sets the OpenstackRegion field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the OpenstackRegion field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithOpenstackRegion(value string) *FelixConfigurationSpecApplyConfiguration {
	b.OpenstackRegion = &value
	return b
}

// WithInterfacePrefix sets the InterfacePrefix field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the InterfacePrefix field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithInterfacePrefix(value string) *FelixConfigurationSpecApplyConfiguration {
	b.InterfacePrefix = &value
	return b
}

// WithInterfaceExclude sets the InterfaceExclude field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the InterfaceExclude field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithInterfaceExclude(value string) *FelixConfigurationSpecApplyConfiguration {
	b.InterfaceExclude = &value
	return b
}

// WithChainInsertMode sets the ChainInsertMode field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the ChainInsertMode field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithChainInsertMode(value string) *FelixConfigurationSpecApplyConfiguration {
	b.ChainInsertMode = &value
	return b
}

// WithDefaultEndpointToHostAction sets the DefaultEndpointToHostAction field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the DefaultEndpointToHostAction field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithDefaultEndpointToHostAction(value string) *FelixConfigurationSpecApplyConfiguration {
	b.DefaultEndpointToHostAction = &value
	return b
}

// WithIptablesFilterAllowAction sets the IptablesFilterAllowAction field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IptablesFilterAllowAction field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIptablesFilterAllowAction(value string) *FelixConfigurationSpecApplyConfiguration {
	b.IptablesFilterAllowAction = &value
	return b
}

// WithIptablesMangleAllowAction sets the IptablesMangleAllowAction field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IptablesMangleAllowAction field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIptablesMangleAllowAction(value string) *FelixConfigurationSpecApplyConfiguration {
	b.IptablesMangleAllowAction = &value
	return b
}

// WithIptablesFilterDenyAction sets the IptablesFilterDenyAction field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IptablesFilterDenyAction field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIptablesFilterDenyAction(value string) *FelixConfigurationSpecApplyConfiguration {
	b.IptablesFilterDenyAction = &value
	return b
}

// WithLogPrefix sets the LogPrefix field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the LogPrefix field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithLogPrefix(value string) *FelixConfigurationSpecApplyConfiguration {
	b.LogPrefix = &value
	return b
}

// WithLogActionRateLimit sets the LogActionRateLimit field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the LogActionRateLimit field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithLogActionRateLimit(value string) *FelixConfigurationSpecApplyConfiguration {
	b.LogActionRateLimit = &value
	return b
}

// WithLogActionRateLimitBurst sets the LogActionRateLimitBurst field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the LogActionRateLimitBurst field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithLogActionRateLimitBurst(value int) *FelixConfigurationSpecApplyConfiguration {
	b.LogActionRateLimitBurst = &value
	return b
}

// WithLogFilePath sets the LogFilePath field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the LogFilePath field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithLogFilePath(value string) *FelixConfigurationSpecApplyConfiguration {
	b.LogFilePath = &value
	return b
}

// WithLogSeverityFile sets the LogSeverityFile field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the LogSeverityFile field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithLogSeverityFile(value string) *FelixConfigurationSpecApplyConfiguration {
	b.LogSeverityFile = &value
	return b
}

// WithLogSeverityScreen sets the LogSeverityScreen field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the LogSeverityScreen field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithLogSeverityScreen(value string) *FelixConfigurationSpecApplyConfiguration {
	b.LogSeverityScreen = &value
	return b
}

// WithLogSeveritySys sets the LogSeveritySys field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the LogSeveritySys field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithLogSeveritySys(value string) *FelixConfigurationSpecApplyConfiguration {
	b.LogSeveritySys = &value
	return b
}

// WithLogDebugFilenameRegex sets the LogDebugFilenameRegex field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the LogDebugFilenameRegex field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithLogDebugFilenameRegex(value string) *FelixConfigurationSpecApplyConfiguration {
	b.LogDebugFilenameRegex = &value
	return b
}

// WithIPIPEnabled sets the IPIPEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IPIPEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIPIPEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.IPIPEnabled = &value
	return b
}

// WithIPIPMTU sets the IPIPMTU field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IPIPMTU field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIPIPMTU(value int) *FelixConfigurationSpecApplyConfiguration {
	b.IPIPMTU = &value
	return b
}

// WithVXLANEnabled sets the VXLANEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the VXLANEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithVXLANEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.VXLANEnabled = &value
	return b
}

// WithVXLANMTU sets the VXLANMTU field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the VXLANMTU field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithVXLANMTU(value int) *FelixConfigurationSpecApplyConfiguration {
	b.VXLANMTU = &value
	return b
}

// WithVXLANMTUV6 sets the VXLANMTUV6 field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the VXLANMTUV6 field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithVXLANMTUV6(value int) *FelixConfigurationSpecApplyConfiguration {
	b.VXLANMTUV6 = &value
	return b
}

// WithVXLANPort sets the VXLANPort field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the VXLANPort field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithVXLANPort(value int) *FelixConfigurationSpecApplyConfiguration {
	b.VXLANPort = &value
	return b
}

// WithVXLANVNI sets the VXLANVNI field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the VXLANVNI field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithVXLANVNI(value int) *FelixConfigurationSpecApplyConfiguration {
	b.VXLANVNI = &value
	return b
}

// WithAllowVXLANPacketsFromWorkloads sets the AllowVXLANPacketsFromWorkloads field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the AllowVXLANPacketsFromWorkloads field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithAllowVXLANPacketsFromWorkloads(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.AllowVXLANPacketsFromWorkloads = &value
	return b
}

// WithAllowIPIPPacketsFromWorkloads sets the AllowIPIPPacketsFromWorkloads field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the AllowIPIPPacketsFromWorkloads field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithAllowIPIPPacketsFromWorkloads(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.AllowIPIPPacketsFromWorkloads = &value
	return b
}

// WithReportingInterval sets the ReportingInterval field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the ReportingInterval field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithReportingInterval(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.ReportingInterval = &value
	return b
}

// WithReportingTTL sets the ReportingTTL field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the ReportingTTL field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithReportingTTL(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.ReportingTTL = &value
	return b
}

// WithEndpointReportingEnabled sets the EndpointReportingEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the EndpointReportingEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithEndpointReportingEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.EndpointReportingEnabled = &value
	return b
}

// WithEndpointReportingDelay sets the EndpointReportingDelay field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the EndpointReportingDelay field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithEndpointReportingDelay(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.EndpointReportingDelay = &value
	return b
}

// WithEndpointStatusPathPrefix sets the EndpointStatusPathPrefix field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the EndpointStatusPathPrefix field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithEndpointStatusPathPrefix(value string) *FelixConfigurationSpecApplyConfiguration {
	b.EndpointStatusPathPrefix = &value
	return b
}

// WithIptablesMarkMask sets the IptablesMarkMask field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IptablesMarkMask field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIptablesMarkMask(value uint32) *FelixConfigurationSpecApplyConfiguration {
	b.IptablesMarkMask = &value
	return b
}

// WithDisableConntrackInvalidCheck sets the DisableConntrackInvalidCheck field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the DisableConntrackInvalidCheck field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithDisableConntrackInvalidCheck(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.DisableConntrackInvalidCheck = &value
	return b
}

// WithHealthEnabled sets the HealthEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the HealthEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithHealthEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.HealthEnabled = &value
	return b
}

// WithHealthHost sets the HealthHost field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the HealthHost field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithHealthHost(value string) *FelixConfigurationSpecApplyConfiguration {
	b.HealthHost = &value
	return b
}

// WithHealthPort sets the HealthPort field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the HealthPort field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithHealthPort(value int) *FelixConfigurationSpecApplyConfiguration {
	b.HealthPort = &value
	return b
}

// WithHealthTimeoutOverrides adds the given value to the HealthTimeoutOverrides field in the declarative configuration
// and returns the receiver, so that objects can be build by chaining "With" function invocations.
// If called multiple times, values provided by each call will be appended to the HealthTimeoutOverrides field.
func (b *FelixConfigurationSpecApplyConfiguration) WithHealthTimeoutOverrides(values ...*HealthTimeoutOverrideApplyConfiguration) *FelixConfigurationSpecApplyConfiguration {
	for i := range values {
		if values[i] == nil {
			panic("nil value passed to WithHealthTimeoutOverrides")
		}
		b.HealthTimeoutOverrides = append(b.HealthTimeoutOverrides, *values[i])
	}
	return b
}

// WithPrometheusMetricsEnabled sets the PrometheusMetricsEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the PrometheusMetricsEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithPrometheusMetricsEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.PrometheusMetricsEnabled = &value
	return b
}

// WithPrometheusMetricsHost sets the PrometheusMetricsHost field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the PrometheusMetricsHost field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithPrometheusMetricsHost(value string) *FelixConfigurationSpecApplyConfiguration {
	b.PrometheusMetricsHost = &value
	return b
}

// WithPrometheusMetricsPort sets the PrometheusMetricsPort field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the PrometheusMetricsPort field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithPrometheusMetricsPort(value int) *FelixConfigurationSpecApplyConfiguration {
	b.PrometheusMetricsPort = &value
	return b
}

// WithPrometheusGoMetricsEnabled sets the PrometheusGoMetricsEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the PrometheusGoMetricsEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithPrometheusGoMetricsEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.PrometheusGoMetricsEnabled = &value
	return b
}

// WithPrometheusProcessMetricsEnabled sets the PrometheusProcessMetricsEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the PrometheusProcessMetricsEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithPrometheusProcessMetricsEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.PrometheusProcessMetricsEnabled = &value
	return b
}

// WithPrometheusWireGuardMetricsEnabled sets the PrometheusWireGuardMetricsEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the PrometheusWireGuardMetricsEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithPrometheusWireGuardMetricsEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.PrometheusWireGuardMetricsEnabled = &value
	return b
}

// WithPrometheusMetricsCAFile sets the PrometheusMetricsCAFile field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the PrometheusMetricsCAFile field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithPrometheusMetricsCAFile(value string) *FelixConfigurationSpecApplyConfiguration {
	b.PrometheusMetricsCAFile = &value
	return b
}

// WithPrometheusMetricsCertFile sets the PrometheusMetricsCertFile field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the PrometheusMetricsCertFile field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithPrometheusMetricsCertFile(value string) *FelixConfigurationSpecApplyConfiguration {
	b.PrometheusMetricsCertFile = &value
	return b
}

// WithPrometheusMetricsKeyFile sets the PrometheusMetricsKeyFile field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the PrometheusMetricsKeyFile field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithPrometheusMetricsKeyFile(value string) *FelixConfigurationSpecApplyConfiguration {
	b.PrometheusMetricsKeyFile = &value
	return b
}

// WithPrometheusMetricsClientAuth sets the PrometheusMetricsClientAuth field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the PrometheusMetricsClientAuth field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithPrometheusMetricsClientAuth(value projectcalicov3.PrometheusMetricsClientAuthType) *FelixConfigurationSpecApplyConfiguration {
	b.PrometheusMetricsClientAuth = &value
	return b
}

func (b *FelixConfigurationSpecApplyConfiguration) ensureProtoPortApplyConfigurationExists() {
	if b.FailsafeInboundHostPorts == nil {
		b.FailsafeInboundHostPorts = &[]ProtoPortApplyConfiguration{}
	}
}

// WithFailsafeInboundHostPorts adds the given value to the FailsafeInboundHostPorts field in the declarative configuration
// and returns the receiver, so that objects can be build by chaining "With" function invocations.
// If called multiple times, values provided by each call will be appended to the FailsafeInboundHostPorts field.
func (b *FelixConfigurationSpecApplyConfiguration) WithFailsafeInboundHostPorts(values ...*ProtoPortApplyConfiguration) *FelixConfigurationSpecApplyConfiguration {
	b.ensureProtoPortApplyConfigurationExists()
	for i := range values {
		if values[i] == nil {
			panic("nil value passed to WithFailsafeInboundHostPorts")
		}
		*b.FailsafeInboundHostPorts = append(*b.FailsafeInboundHostPorts, *values[i])
	}
	return b
}

func (b *FelixConfigurationSpecApplyConfiguration) ensureOutboundProtoPortApplyConfigurationExists() {
	if b.FailsafeOutboundHostPorts == nil {
		b.FailsafeOutboundHostPorts = &[]ProtoPortApplyConfiguration{}
	}
}

// WithFailsafeOutboundHostPorts adds the given value to the FailsafeOutboundHostPorts field in the declarative configuration
// and returns the receiver, so that objects can be build by chaining "With" function invocations.
// If called multiple times, values provided by each call will be appended to the FailsafeOutboundHostPorts field.
func (b *FelixConfigurationSpecApplyConfiguration) WithFailsafeOutboundHostPorts(values ...*ProtoPortApplyConfiguration) *FelixConfigurationSpecApplyConfiguration {
	b.ensureOutboundProtoPortApplyConfigurationExists()
	for i := range values {
		if values[i] == nil {
			panic("nil value passed to WithFailsafeOutboundHostPorts")
		}
		*b.FailsafeOutboundHostPorts = append(*b.FailsafeOutboundHostPorts, *values[i])
	}
	return b
}

// WithKubeNodePortRanges sets the KubeNodePortRanges field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the KubeNodePortRanges field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithKubeNodePortRanges(value []numorstring.Port) *FelixConfigurationSpecApplyConfiguration {
	b.KubeNodePortRanges = &value
	return b
}

// WithPolicySyncPathPrefix sets the PolicySyncPathPrefix field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the PolicySyncPathPrefix field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithPolicySyncPathPrefix(value string) *FelixConfigurationSpecApplyConfiguration {
	b.PolicySyncPathPrefix = &value
	return b
}

// WithUsageReportingEnabled sets the UsageReportingEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the UsageReportingEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithUsageReportingEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.UsageReportingEnabled = &value
	return b
}

// WithUsageReportingInitialDelay sets the UsageReportingInitialDelay field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the UsageReportingInitialDelay field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithUsageReportingInitialDelay(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.UsageReportingInitialDelay = &value
	return b
}

// WithUsageReportingInterval sets the UsageReportingInterval field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the UsageReportingInterval field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithUsageReportingInterval(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.UsageReportingInterval = &value
	return b
}

// WithNATPortRange sets the NATPortRange field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the NATPortRange field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithNATPortRange(value numorstring.Port) *FelixConfigurationSpecApplyConfiguration {
	b.NATPortRange = &value
	return b
}

// WithNATOutgoingAddress sets the NATOutgoingAddress field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the NATOutgoingAddress field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithNATOutgoingAddress(value string) *FelixConfigurationSpecApplyConfiguration {
	b.NATOutgoingAddress = &value
	return b
}

// WithNATOutgoingExclusions sets the NATOutgoingExclusions field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the NATOutgoingExclusions field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithNATOutgoingExclusions(value projectcalicov3.NATOutgoingExclusionsType) *FelixConfigurationSpecApplyConfiguration {
	b.NATOutgoingExclusions = &value
	return b
}

// WithDeviceRouteSourceAddress sets the DeviceRouteSourceAddress field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the DeviceRouteSourceAddress field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithDeviceRouteSourceAddress(value string) *FelixConfigurationSpecApplyConfiguration {
	b.DeviceRouteSourceAddress = &value
	return b
}

// WithDeviceRouteSourceAddressIPv6 sets the DeviceRouteSourceAddressIPv6 field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the DeviceRouteSourceAddressIPv6 field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithDeviceRouteSourceAddressIPv6(value string) *FelixConfigurationSpecApplyConfiguration {
	b.DeviceRouteSourceAddressIPv6 = &value
	return b
}

// WithDeviceRouteProtocol sets the DeviceRouteProtocol field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the DeviceRouteProtocol field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithDeviceRouteProtocol(value int) *FelixConfigurationSpecApplyConfiguration {
	b.DeviceRouteProtocol = &value
	return b
}

// WithRemoveExternalRoutes sets the RemoveExternalRoutes field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the RemoveExternalRoutes field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithRemoveExternalRoutes(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.RemoveExternalRoutes = &value
	return b
}

// WithProgramClusterRoutes sets the ProgramClusterRoutes field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the ProgramClusterRoutes field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithProgramClusterRoutes(value string) *FelixConfigurationSpecApplyConfiguration {
	b.ProgramClusterRoutes = &value
	return b
}

// WithIPForwarding sets the IPForwarding field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IPForwarding field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIPForwarding(value string) *FelixConfigurationSpecApplyConfiguration {
	b.IPForwarding = &value
	return b
}

// WithExternalNodesCIDRList sets the ExternalNodesCIDRList field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the ExternalNodesCIDRList field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithExternalNodesCIDRList(value []string) *FelixConfigurationSpecApplyConfiguration {
	b.ExternalNodesCIDRList = &value
	return b
}

// WithDebugMemoryProfilePath sets the DebugMemoryProfilePath field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the DebugMemoryProfilePath field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithDebugMemoryProfilePath(value string) *FelixConfigurationSpecApplyConfiguration {
	b.DebugMemoryProfilePath = &value
	return b
}

// WithDebugDisableLogDropping sets the DebugDisableLogDropping field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the DebugDisableLogDropping field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithDebugDisableLogDropping(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.DebugDisableLogDropping = &value
	return b
}

// WithDebugSimulateCalcGraphHangAfter sets the DebugSimulateCalcGraphHangAfter field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the DebugSimulateCalcGraphHangAfter field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithDebugSimulateCalcGraphHangAfter(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.DebugSimulateCalcGraphHangAfter = &value
	return b
}

// WithDebugSimulateDataplaneHangAfter sets the DebugSimulateDataplaneHangAfter field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the DebugSimulateDataplaneHangAfter field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithDebugSimulateDataplaneHangAfter(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.DebugSimulateDataplaneHangAfter = &value
	return b
}

// WithDebugSimulateDataplaneApplyDelay sets the DebugSimulateDataplaneApplyDelay field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the DebugSimulateDataplaneApplyDelay field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithDebugSimulateDataplaneApplyDelay(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.DebugSimulateDataplaneApplyDelay = &value
	return b
}

// WithDebugHost sets the DebugHost field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the DebugHost field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithDebugHost(value string) *FelixConfigurationSpecApplyConfiguration {
	b.DebugHost = &value
	return b
}

// WithDebugPort sets the DebugPort field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the DebugPort field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithDebugPort(value int) *FelixConfigurationSpecApplyConfiguration {
	b.DebugPort = &value
	return b
}

// WithIptablesNATOutgoingInterfaceFilter sets the IptablesNATOutgoingInterfaceFilter field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IptablesNATOutgoingInterfaceFilter field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIptablesNATOutgoingInterfaceFilter(value string) *FelixConfigurationSpecApplyConfiguration {
	b.IptablesNATOutgoingInterfaceFilter = &value
	return b
}

// WithSidecarAccelerationEnabled sets the SidecarAccelerationEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the SidecarAccelerationEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithSidecarAccelerationEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.SidecarAccelerationEnabled = &value
	return b
}

// WithXDPEnabled sets the XDPEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the XDPEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithXDPEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.XDPEnabled = &value
	return b
}

// WithGenericXDPEnabled sets the GenericXDPEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the GenericXDPEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithGenericXDPEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.GenericXDPEnabled = &value
	return b
}

// WithNFTablesMode sets the NFTablesMode field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the NFTablesMode field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithNFTablesMode(value projectcalicov3.NFTablesMode) *FelixConfigurationSpecApplyConfiguration {
	b.NFTablesMode = &value
	return b
}

// WithNftablesRefreshInterval sets the NftablesRefreshInterval field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the NftablesRefreshInterval field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithNftablesRefreshInterval(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.NftablesRefreshInterval = &value
	return b
}

// WithNftablesFilterAllowAction sets the NftablesFilterAllowAction field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the NftablesFilterAllowAction field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithNftablesFilterAllowAction(value string) *FelixConfigurationSpecApplyConfiguration {
	b.NftablesFilterAllowAction = &value
	return b
}

// WithNftablesMangleAllowAction sets the NftablesMangleAllowAction field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the NftablesMangleAllowAction field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithNftablesMangleAllowAction(value string) *FelixConfigurationSpecApplyConfiguration {
	b.NftablesMangleAllowAction = &value
	return b
}

// WithNftablesFilterDenyAction sets the NftablesFilterDenyAction field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the NftablesFilterDenyAction field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithNftablesFilterDenyAction(value string) *FelixConfigurationSpecApplyConfiguration {
	b.NftablesFilterDenyAction = &value
	return b
}

// WithNftablesMarkMask sets the NftablesMarkMask field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the NftablesMarkMask field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithNftablesMarkMask(value uint32) *FelixConfigurationSpecApplyConfiguration {
	b.NftablesMarkMask = &value
	return b
}

// WithBPFEnabled sets the BPFEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.BPFEnabled = &value
	return b
}

// WithBPFDisableUnprivileged sets the BPFDisableUnprivileged field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFDisableUnprivileged field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFDisableUnprivileged(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.BPFDisableUnprivileged = &value
	return b
}

// WithBPFJITHardening sets the BPFJITHardening field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFJITHardening field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFJITHardening(value projectcalicov3.BPFJITHardeningType) *FelixConfigurationSpecApplyConfiguration {
	b.BPFJITHardening = &value
	return b
}

// WithBPFLogLevel sets the BPFLogLevel field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFLogLevel field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFLogLevel(value string) *FelixConfigurationSpecApplyConfiguration {
	b.BPFLogLevel = &value
	return b
}

// WithBPFConntrackLogLevel sets the BPFConntrackLogLevel field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFConntrackLogLevel field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFConntrackLogLevel(value string) *FelixConfigurationSpecApplyConfiguration {
	b.BPFConntrackLogLevel = &value
	return b
}

// WithBPFConntrackCleanupMode sets the BPFConntrackCleanupMode field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFConntrackCleanupMode field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFConntrackCleanupMode(value projectcalicov3.BPFConntrackMode) *FelixConfigurationSpecApplyConfiguration {
	b.BPFConntrackCleanupMode = &value
	return b
}

// WithBPFConntrackTimeouts sets the BPFConntrackTimeouts field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFConntrackTimeouts field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFConntrackTimeouts(value *BPFConntrackTimeoutsApplyConfiguration) *FelixConfigurationSpecApplyConfiguration {
	b.BPFConntrackTimeouts = value
	return b
}

// WithBPFLogFilters sets the BPFLogFilters field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFLogFilters field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFLogFilters(value map[string]string) *FelixConfigurationSpecApplyConfiguration {
	b.BPFLogFilters = &value
	return b
}

// WithBPFCTLBLogFilter sets the BPFCTLBLogFilter field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFCTLBLogFilter field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFCTLBLogFilter(value string) *FelixConfigurationSpecApplyConfiguration {
	b.BPFCTLBLogFilter = &value
	return b
}

// WithBPFDataIfacePattern sets the BPFDataIfacePattern field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFDataIfacePattern field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFDataIfacePattern(value string) *FelixConfigurationSpecApplyConfiguration {
	b.BPFDataIfacePattern = &value
	return b
}

// WithBPFL3IfacePattern sets the BPFL3IfacePattern field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFL3IfacePattern field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFL3IfacePattern(value string) *FelixConfigurationSpecApplyConfiguration {
	b.BPFL3IfacePattern = &value
	return b
}

// WithBPFConnectTimeLoadBalancingEnabled sets the BPFConnectTimeLoadBalancingEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFConnectTimeLoadBalancingEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFConnectTimeLoadBalancingEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.BPFConnectTimeLoadBalancingEnabled = &value
	return b
}

// WithBPFConnectTimeLoadBalancing sets the BPFConnectTimeLoadBalancing field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFConnectTimeLoadBalancing field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFConnectTimeLoadBalancing(value projectcalicov3.BPFConnectTimeLBType) *FelixConfigurationSpecApplyConfiguration {
	b.BPFConnectTimeLoadBalancing = &value
	return b
}

// WithBPFHostNetworkedNATWithoutCTLB sets the BPFHostNetworkedNATWithoutCTLB field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFHostNetworkedNATWithoutCTLB field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFHostNetworkedNATWithoutCTLB(value projectcalicov3.BPFHostNetworkedNATType) *FelixConfigurationSpecApplyConfiguration {
	b.BPFHostNetworkedNATWithoutCTLB = &value
	return b
}

// WithBPFExternalServiceMode sets the BPFExternalServiceMode field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFExternalServiceMode field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFExternalServiceMode(value string) *FelixConfigurationSpecApplyConfiguration {
	b.BPFExternalServiceMode = &value
	return b
}

// WithBPFDSROptoutCIDRs sets the BPFDSROptoutCIDRs field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFDSROptoutCIDRs field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFDSROptoutCIDRs(value []string) *FelixConfigurationSpecApplyConfiguration {
	b.BPFDSROptoutCIDRs = &value
	return b
}

// WithBPFExtToServiceConnmark sets the BPFExtToServiceConnmark field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFExtToServiceConnmark field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFExtToServiceConnmark(value int) *FelixConfigurationSpecApplyConfiguration {
	b.BPFExtToServiceConnmark = &value
	return b
}

// WithBPFKubeProxyIptablesCleanupEnabled sets the BPFKubeProxyIptablesCleanupEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFKubeProxyIptablesCleanupEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFKubeProxyIptablesCleanupEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.BPFKubeProxyIptablesCleanupEnabled = &value
	return b
}

// WithBPFKubeProxyMinSyncPeriod sets the BPFKubeProxyMinSyncPeriod field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFKubeProxyMinSyncPeriod field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFKubeProxyMinSyncPeriod(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.BPFKubeProxyMinSyncPeriod = &value
	return b
}

// WithBPFKubeProxyHealthzPort sets the BPFKubeProxyHealthzPort field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFKubeProxyHealthzPort field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFKubeProxyHealthzPort(value int) *FelixConfigurationSpecApplyConfiguration {
	b.BPFKubeProxyHealthzPort = &value
	return b
}

// WithBPFPSNATPorts sets the BPFPSNATPorts field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFPSNATPorts field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFPSNATPorts(value numorstring.Port) *FelixConfigurationSpecApplyConfiguration {
	b.BPFPSNATPorts = &value
	return b
}

// WithBPFMapSizeNATFrontend sets the BPFMapSizeNATFrontend field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFMapSizeNATFrontend field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFMapSizeNATFrontend(value int) *FelixConfigurationSpecApplyConfiguration {
	b.BPFMapSizeNATFrontend = &value
	return b
}

// WithBPFMapSizeNATBackend sets the BPFMapSizeNATBackend field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFMapSizeNATBackend field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFMapSizeNATBackend(value int) *FelixConfigurationSpecApplyConfiguration {
	b.BPFMapSizeNATBackend = &value
	return b
}

// WithBPFMapSizeNATAffinity sets the BPFMapSizeNATAffinity field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFMapSizeNATAffinity field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFMapSizeNATAffinity(value int) *FelixConfigurationSpecApplyConfiguration {
	b.BPFMapSizeNATAffinity = &value
	return b
}

// WithBPFMapSizeRoute sets the BPFMapSizeRoute field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFMapSizeRoute field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFMapSizeRoute(value int) *FelixConfigurationSpecApplyConfiguration {
	b.BPFMapSizeRoute = &value
	return b
}

// WithBPFMapSizeConntrack sets the BPFMapSizeConntrack field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFMapSizeConntrack field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFMapSizeConntrack(value int) *FelixConfigurationSpecApplyConfiguration {
	b.BPFMapSizeConntrack = &value
	return b
}

// WithBPFMapSizePerCPUConntrack sets the BPFMapSizePerCPUConntrack field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFMapSizePerCPUConntrack field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFMapSizePerCPUConntrack(value int) *FelixConfigurationSpecApplyConfiguration {
	b.BPFMapSizePerCPUConntrack = &value
	return b
}

// WithBPFMapSizeConntrackScaling sets the BPFMapSizeConntrackScaling field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFMapSizeConntrackScaling field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFMapSizeConntrackScaling(value string) *FelixConfigurationSpecApplyConfiguration {
	b.BPFMapSizeConntrackScaling = &value
	return b
}

// WithBPFMapSizeConntrackCleanupQueue sets the BPFMapSizeConntrackCleanupQueue field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFMapSizeConntrackCleanupQueue field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFMapSizeConntrackCleanupQueue(value int) *FelixConfigurationSpecApplyConfiguration {
	b.BPFMapSizeConntrackCleanupQueue = &value
	return b
}

// WithBPFMapSizeIPSets sets the BPFMapSizeIPSets field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFMapSizeIPSets field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFMapSizeIPSets(value int) *FelixConfigurationSpecApplyConfiguration {
	b.BPFMapSizeIPSets = &value
	return b
}

// WithBPFMapSizeIfState sets the BPFMapSizeIfState field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFMapSizeIfState field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFMapSizeIfState(value int) *FelixConfigurationSpecApplyConfiguration {
	b.BPFMapSizeIfState = &value
	return b
}

// WithBPFHostConntrackBypass sets the BPFHostConntrackBypass field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFHostConntrackBypass field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFHostConntrackBypass(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.BPFHostConntrackBypass = &value
	return b
}

// WithBPFEnforceRPF sets the BPFEnforceRPF field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFEnforceRPF field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFEnforceRPF(value string) *FelixConfigurationSpecApplyConfiguration {
	b.BPFEnforceRPF = &value
	return b
}

// WithBPFPolicyDebugEnabled sets the BPFPolicyDebugEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFPolicyDebugEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFPolicyDebugEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.BPFPolicyDebugEnabled = &value
	return b
}

// WithBPFForceTrackPacketsFromIfaces sets the BPFForceTrackPacketsFromIfaces field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFForceTrackPacketsFromIfaces field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFForceTrackPacketsFromIfaces(value []string) *FelixConfigurationSpecApplyConfiguration {
	b.BPFForceTrackPacketsFromIfaces = &value
	return b
}

// WithBPFDisableGROForIfaces sets the BPFDisableGROForIfaces field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFDisableGROForIfaces field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFDisableGROForIfaces(value string) *FelixConfigurationSpecApplyConfiguration {
	b.BPFDisableGROForIfaces = &value
	return b
}

// WithBPFExcludeCIDRsFromNAT sets the BPFExcludeCIDRsFromNAT field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFExcludeCIDRsFromNAT field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFExcludeCIDRsFromNAT(value []string) *FelixConfigurationSpecApplyConfiguration {
	b.BPFExcludeCIDRsFromNAT = &value
	return b
}

// WithBPFExportBufferSizeMB sets the BPFExportBufferSizeMB field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFExportBufferSizeMB field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFExportBufferSizeMB(value int) *FelixConfigurationSpecApplyConfiguration {
	b.BPFExportBufferSizeMB = &value
	return b
}

// WithIstioAmbientMode sets the IstioAmbientMode field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IstioAmbientMode field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIstioAmbientMode(value projectcalicov3.IstioAmbientMode) *FelixConfigurationSpecApplyConfiguration {
	b.IstioAmbientMode = &value
	return b
}

// WithIstioDSCPMark sets the IstioDSCPMark field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IstioDSCPMark field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIstioDSCPMark(value numorstring.DSCP) *FelixConfigurationSpecApplyConfiguration {
	b.IstioDSCPMark = &value
	return b
}

// WithCgroupV2Path sets the CgroupV2Path field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the CgroupV2Path field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithCgroupV2Path(value string) *FelixConfigurationSpecApplyConfiguration {
	b.CgroupV2Path = &value
	return b
}

// WithFlowLogsPolicyEvaluationMode sets the FlowLogsPolicyEvaluationMode field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the FlowLogsPolicyEvaluationMode field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithFlowLogsPolicyEvaluationMode(value projectcalicov3.FlowLogsPolicyEvaluationModeType) *FelixConfigurationSpecApplyConfiguration {
	b.FlowLogsPolicyEvaluationMode = &value
	return b
}

// WithBPFRedirectToPeer sets the BPFRedirectToPeer field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFRedirectToPeer field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFRedirectToPeer(value string) *FelixConfigurationSpecApplyConfiguration {
	b.BPFRedirectToPeer = &value
	return b
}

// WithBPFAttachType sets the BPFAttachType field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFAttachType field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFAttachType(value projectcalicov3.BPFAttachOption) *FelixConfigurationSpecApplyConfiguration {
	b.BPFAttachType = &value
	return b
}

// WithFlowLogsFlushInterval sets the FlowLogsFlushInterval field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the FlowLogsFlushInterval field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithFlowLogsFlushInterval(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.FlowLogsFlushInterval = &value
	return b
}

// WithFlowLogsCollectorDebugTrace sets the FlowLogsCollectorDebugTrace field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the FlowLogsCollectorDebugTrace field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithFlowLogsCollectorDebugTrace(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.FlowLogsCollectorDebugTrace = &value
	return b
}

// WithFlowLogsGoldmaneServer sets the FlowLogsGoldmaneServer field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the FlowLogsGoldmaneServer field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithFlowLogsGoldmaneServer(value string) *FelixConfigurationSpecApplyConfiguration {
	b.FlowLogsGoldmaneServer = &value
	return b
}

// WithFlowLogsLocalReporter sets the FlowLogsLocalReporter field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the FlowLogsLocalReporter field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithFlowLogsLocalReporter(value string) *FelixConfigurationSpecApplyConfiguration {
	b.FlowLogsLocalReporter = &value
	return b
}

// WithBPFProfiling sets the BPFProfiling field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFProfiling field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFProfiling(value string) *FelixConfigurationSpecApplyConfiguration {
	b.BPFProfiling = &value
	return b
}

// WithRouteSource sets the RouteSource field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the RouteSource field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithRouteSource(value string) *FelixConfigurationSpecApplyConfiguration {
	b.RouteSource = &value
	return b
}

// WithRouteTableRanges sets the RouteTableRanges field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the RouteTableRanges field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithRouteTableRanges(value projectcalicov3.RouteTableRanges) *FelixConfigurationSpecApplyConfiguration {
	b.RouteTableRanges = &value
	return b
}

// WithRouteTableRange sets the RouteTableRange field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the RouteTableRange field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithRouteTableRange(value *RouteTableRangeApplyConfiguration) *FelixConfigurationSpecApplyConfiguration {
	b.RouteTableRange = value
	return b
}

// WithRouteSyncDisabled sets the RouteSyncDisabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the RouteSyncDisabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithRouteSyncDisabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.RouteSyncDisabled = &value
	return b
}

// WithIPv4NormalRoutePriority sets the IPv4NormalRoutePriority field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IPv4NormalRoutePriority field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIPv4NormalRoutePriority(value int) *FelixConfigurationSpecApplyConfiguration {
	b.IPv4NormalRoutePriority = &value
	return b
}

// WithIPv4ElevatedRoutePriority sets the IPv4ElevatedRoutePriority field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IPv4ElevatedRoutePriority field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIPv4ElevatedRoutePriority(value int) *FelixConfigurationSpecApplyConfiguration {
	b.IPv4ElevatedRoutePriority = &value
	return b
}

// WithIPv6NormalRoutePriority sets the IPv6NormalRoutePriority field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IPv6NormalRoutePriority field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIPv6NormalRoutePriority(value int) *FelixConfigurationSpecApplyConfiguration {
	b.IPv6NormalRoutePriority = &value
	return b
}

// WithIPv6ElevatedRoutePriority sets the IPv6ElevatedRoutePriority field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the IPv6ElevatedRoutePriority field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithIPv6ElevatedRoutePriority(value int) *FelixConfigurationSpecApplyConfiguration {
	b.IPv6ElevatedRoutePriority = &value
	return b
}

// WithLiveMigrationRouteConvergenceTime sets the LiveMigrationRouteConvergenceTime field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the LiveMigrationRouteConvergenceTime field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithLiveMigrationRouteConvergenceTime(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.LiveMigrationRouteConvergenceTime = &value
	return b
}

// WithWireguardEnabled sets the WireguardEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the WireguardEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithWireguardEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.WireguardEnabled = &value
	return b
}

// WithWireguardEnabledV6 sets the WireguardEnabledV6 field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the WireguardEnabledV6 field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithWireguardEnabledV6(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.WireguardEnabledV6 = &value
	return b
}

// WithWireguardThreadingEnabled sets the WireguardThreadingEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the WireguardThreadingEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithWireguardThreadingEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.WireguardThreadingEnabled = &value
	return b
}

// WithWireguardListeningPort sets the WireguardListeningPort field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the WireguardListeningPort field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithWireguardListeningPort(value int) *FelixConfigurationSpecApplyConfiguration {
	b.WireguardListeningPort = &value
	return b
}

// WithWireguardListeningPortV6 sets the WireguardListeningPortV6 field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the WireguardListeningPortV6 field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithWireguardListeningPortV6(value int) *FelixConfigurationSpecApplyConfiguration {
	b.WireguardListeningPortV6 = &value
	return b
}

// WithWireguardRoutingRulePriority sets the WireguardRoutingRulePriority field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the WireguardRoutingRulePriority field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithWireguardRoutingRulePriority(value int) *FelixConfigurationSpecApplyConfiguration {
	b.WireguardRoutingRulePriority = &value
	return b
}

// WithWireguardInterfaceName sets the WireguardInterfaceName field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the WireguardInterfaceName field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithWireguardInterfaceName(value string) *FelixConfigurationSpecApplyConfiguration {
	b.WireguardInterfaceName = &value
	return b
}

// WithWireguardInterfaceNameV6 sets the WireguardInterfaceNameV6 field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the WireguardInterfaceNameV6 field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithWireguardInterfaceNameV6(value string) *FelixConfigurationSpecApplyConfiguration {
	b.WireguardInterfaceNameV6 = &value
	return b
}

// WithWireguardMTU sets the WireguardMTU field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the WireguardMTU field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithWireguardMTU(value int) *FelixConfigurationSpecApplyConfiguration {
	b.WireguardMTU = &value
	return b
}

// WithWireguardMTUV6 sets the WireguardMTUV6 field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the WireguardMTUV6 field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithWireguardMTUV6(value int) *FelixConfigurationSpecApplyConfiguration {
	b.WireguardMTUV6 = &value
	return b
}

// WithWireguardHostEncryptionEnabled sets the WireguardHostEncryptionEnabled field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the WireguardHostEncryptionEnabled field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithWireguardHostEncryptionEnabled(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.WireguardHostEncryptionEnabled = &value
	return b
}

// WithWireguardPersistentKeepAlive sets the WireguardPersistentKeepAlive field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the WireguardPersistentKeepAlive field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithWireguardPersistentKeepAlive(value v1.Duration) *FelixConfigurationSpecApplyConfiguration {
	b.WireguardPersistentKeepAlive = &value
	return b
}

// WithAWSSrcDstCheck sets the AWSSrcDstCheck field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the AWSSrcDstCheck field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithAWSSrcDstCheck(value projectcalicov3.AWSSrcDstCheckOption) *FelixConfigurationSpecApplyConfiguration {
	b.AWSSrcDstCheck = &value
	return b
}

// WithServiceLoopPrevention sets the ServiceLoopPrevention field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the ServiceLoopPrevention field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithServiceLoopPrevention(value string) *FelixConfigurationSpecApplyConfiguration {
	b.ServiceLoopPrevention = &value
	return b
}

// WithWorkloadSourceSpoofing sets the WorkloadSourceSpoofing field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the WorkloadSourceSpoofing field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithWorkloadSourceSpoofing(value string) *FelixConfigurationSpecApplyConfiguration {
	b.WorkloadSourceSpoofing = &value
	return b
}

// WithMTUIfacePattern sets the MTUIfacePattern field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the MTUIfacePattern field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithMTUIfacePattern(value string) *FelixConfigurationSpecApplyConfiguration {
	b.MTUIfacePattern = &value
	return b
}

// WithFloatingIPs sets the FloatingIPs field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the FloatingIPs field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithFloatingIPs(value projectcalicov3.FloatingIPType) *FelixConfigurationSpecApplyConfiguration {
	b.FloatingIPs = &value
	return b
}

// WithWindowsManageFirewallRules sets the WindowsManageFirewallRules field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the WindowsManageFirewallRules field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithWindowsManageFirewallRules(value projectcalicov3.WindowsManageFirewallRulesMode) *FelixConfigurationSpecApplyConfiguration {
	b.WindowsManageFirewallRules = &value
	return b
}

// WithGoGCThreshold sets the GoGCThreshold field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the GoGCThreshold field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithGoGCThreshold(value int) *FelixConfigurationSpecApplyConfiguration {
	b.GoGCThreshold = &value
	return b
}

// WithGoMemoryLimitMB sets the GoMemoryLimitMB field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the GoMemoryLimitMB field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithGoMemoryLimitMB(value int) *FelixConfigurationSpecApplyConfiguration {
	b.GoMemoryLimitMB = &value
	return b
}

// WithGoMaxProcs sets the GoMaxProcs field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the GoMaxProcs field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithGoMaxProcs(value int) *FelixConfigurationSpecApplyConfiguration {
	b.GoMaxProcs = &value
	return b
}

// WithRequireMTUFile sets the RequireMTUFile field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the RequireMTUFile field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithRequireMTUFile(value bool) *FelixConfigurationSpecApplyConfiguration {
	b.RequireMTUFile = &value
	return b
}

// WithBPFMaglevMaxEndpointsPerService sets the BPFMaglevMaxEndpointsPerService field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFMaglevMaxEndpointsPerService field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFMaglevMaxEndpointsPerService(value int) *FelixConfigurationSpecApplyConfiguration {
	b.BPFMaglevMaxEndpointsPerService = &value
	return b
}

// WithBPFMaglevMaxServices sets the BPFMaglevMaxServices field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the BPFMaglevMaxServices field is set to the value of the last call.
func (b *FelixConfigurationSpecApplyConfiguration) WithBPFMaglevMaxServices(value int) *FelixConfigurationSpecApplyConfiguration {
	b.BPFMaglevMaxServices = &value
	return b
}
