models

package
v5.1.15 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 28, 2024 License: Apache-2.0 Imports: 8 Imported by: 73

Documentation ¶

Index ¶

Constants ¶

View Source 
const (

	// AwsRegionIPV4AddressPrivate captures enum value "private"
	AwsRegionIPV4AddressPrivate string = "private"

	// AwsRegionIPV4AddressPublic captures enum value "public"
	AwsRegionIPV4AddressPublic string = "public"
)
View Source 
const (

	// AwsRegionServerSlotsGrowthTypeLinear captures enum value "linear"
	AwsRegionServerSlotsGrowthTypeLinear string = "linear"

	// AwsRegionServerSlotsGrowthTypeExponential captures enum value "exponential"
	AwsRegionServerSlotsGrowthTypeExponential string = "exponential"
)
View Source 
const (

	// BackendAbortoncloseEnabled captures enum value "enabled"
	BackendAbortoncloseEnabled string = "enabled"

	// BackendAbortoncloseDisabled captures enum value "disabled"
	BackendAbortoncloseDisabled string = "disabled"
)
View Source 
const (

	// BackendAcceptInvalidHTTPResponseEnabled captures enum value "enabled"
	BackendAcceptInvalidHTTPResponseEnabled string = "enabled"

	// BackendAcceptInvalidHTTPResponseDisabled captures enum value "disabled"
	BackendAcceptInvalidHTTPResponseDisabled string = "disabled"
)
View Source 
const (

	// BackendAdvCheckHttpchk captures enum value "httpchk"
	BackendAdvCheckHttpchk string = "httpchk"

	// BackendAdvCheckLdapDashCheck captures enum value "ldap-check"
	BackendAdvCheckLdapDashCheck string = "ldap-check"

	// BackendAdvCheckMysqlDashCheck captures enum value "mysql-check"
	BackendAdvCheckMysqlDashCheck string = "mysql-check"

	// BackendAdvCheckPgsqlDashCheck captures enum value "pgsql-check"
	BackendAdvCheckPgsqlDashCheck string = "pgsql-check"

	// BackendAdvCheckRedisDashCheck captures enum value "redis-check"
	BackendAdvCheckRedisDashCheck string = "redis-check"

	// BackendAdvCheckSmtpchk captures enum value "smtpchk"
	BackendAdvCheckSmtpchk string = "smtpchk"

	// BackendAdvCheckSslDashHelloDashChk captures enum value "ssl-hello-chk"
	BackendAdvCheckSslDashHelloDashChk string = "ssl-hello-chk"

	// BackendAdvCheckTCPDashCheck captures enum value "tcp-check"
	BackendAdvCheckTCPDashCheck string = "tcp-check"
)
View Source 
const (

	// BackendAllbackupsEnabled captures enum value "enabled"
	BackendAllbackupsEnabled string = "enabled"

	// BackendAllbackupsDisabled captures enum value "disabled"
	BackendAllbackupsDisabled string = "disabled"
)
View Source 
const (

	// BackendCheckcacheEnabled captures enum value "enabled"
	BackendCheckcacheEnabled string = "enabled"

	// BackendCheckcacheDisabled captures enum value "disabled"
	BackendCheckcacheDisabled string = "disabled"
)
View Source 
const (

	// BackendExternalCheckEnabled captures enum value "enabled"
	BackendExternalCheckEnabled string = "enabled"

	// BackendExternalCheckDisabled captures enum value "disabled"
	BackendExternalCheckDisabled string = "disabled"
)
View Source 
const (

	// BackendH1CaseAdjustBogusServerEnabled captures enum value "enabled"
	BackendH1CaseAdjustBogusServerEnabled string = "enabled"

	// BackendH1CaseAdjustBogusServerDisabled captures enum value "disabled"
	BackendH1CaseAdjustBogusServerDisabled string = "disabled"
)
View Source 
const (

	// BackendHTTPBufferRequestEnabled captures enum value "enabled"
	BackendHTTPBufferRequestEnabled string = "enabled"

	// BackendHTTPBufferRequestDisabled captures enum value "disabled"
	BackendHTTPBufferRequestDisabled string = "disabled"
)
View Source 
const (

	// BackendHTTPKeepAliveEnabled captures enum value "enabled"
	BackendHTTPKeepAliveEnabled string = "enabled"

	// BackendHTTPKeepAliveDisabled captures enum value "disabled"
	BackendHTTPKeepAliveDisabled string = "disabled"
)
View Source 
const (

	// BackendHTTPNoDelayEnabled captures enum value "enabled"
	BackendHTTPNoDelayEnabled string = "enabled"

	// BackendHTTPNoDelayDisabled captures enum value "disabled"
	BackendHTTPNoDelayDisabled string = "disabled"
)
View Source 
const (

	// BackendHTTPServerCloseEnabled captures enum value "enabled"
	BackendHTTPServerCloseEnabled string = "enabled"

	// BackendHTTPServerCloseDisabled captures enum value "disabled"
	BackendHTTPServerCloseDisabled string = "disabled"
)
View Source 
const (

	// BackendHTTPUseHtxEnabled captures enum value "enabled"
	BackendHTTPUseHtxEnabled string = "enabled"

	// BackendHTTPUseHtxDisabled captures enum value "disabled"
	BackendHTTPUseHtxDisabled string = "disabled"
)
View Source 
const (

	// BackendHTTPConnectionModeHttpclose captures enum value "httpclose"
	BackendHTTPConnectionModeHttpclose string = "httpclose"

	// BackendHTTPConnectionModeHTTPDashServerDashClose captures enum value "http-server-close"
	BackendHTTPConnectionModeHTTPDashServerDashClose string = "http-server-close"

	// BackendHTTPConnectionModeHTTPDashKeepDashAlive captures enum value "http-keep-alive"
	BackendHTTPConnectionModeHTTPDashKeepDashAlive string = "http-keep-alive"
)
View Source 
const (

	// BackendHTTPPretendKeepaliveEnabled captures enum value "enabled"
	BackendHTTPPretendKeepaliveEnabled string = "enabled"

	// BackendHTTPPretendKeepaliveDisabled captures enum value "disabled"
	BackendHTTPPretendKeepaliveDisabled string = "disabled"
)
View Source 
const (

	// BackendHTTPProxyEnabled captures enum value "enabled"
	BackendHTTPProxyEnabled string = "enabled"

	// BackendHTTPProxyDisabled captures enum value "disabled"
	BackendHTTPProxyDisabled string = "disabled"
)
View Source 
const (

	// BackendHTTPRestrictReqHdrNamesPreserve captures enum value "preserve"
	BackendHTTPRestrictReqHdrNamesPreserve string = "preserve"

	// BackendHTTPRestrictReqHdrNamesDelete captures enum value "delete"
	BackendHTTPRestrictReqHdrNamesDelete string = "delete"

	// BackendHTTPRestrictReqHdrNamesReject captures enum value "reject"
	BackendHTTPRestrictReqHdrNamesReject string = "reject"
)
View Source 
const (

	// BackendHTTPReuseAggressive captures enum value "aggressive"
	BackendHTTPReuseAggressive string = "aggressive"

	// BackendHTTPReuseAlways captures enum value "always"
	BackendHTTPReuseAlways string = "always"

	// BackendHTTPReuseNever captures enum value "never"
	BackendHTTPReuseNever string = "never"

	// BackendHTTPReuseSafe captures enum value "safe"
	BackendHTTPReuseSafe string = "safe"
)
View Source 
const (

	// BackendHttpcloseEnabled captures enum value "enabled"
	BackendHttpcloseEnabled string = "enabled"

	// BackendHttpcloseDisabled captures enum value "disabled"
	BackendHttpcloseDisabled string = "disabled"
)
View Source 
const (

	// BackendIndependentStreamsEnabled captures enum value "enabled"
	BackendIndependentStreamsEnabled string = "enabled"

	// BackendIndependentStreamsDisabled captures enum value "disabled"
	BackendIndependentStreamsDisabled string = "disabled"
)
View Source 
const (

	// BackendLoadServerStateFromFileGlobal captures enum value "global"
	BackendLoadServerStateFromFileGlobal string = "global"

	// BackendLoadServerStateFromFileLocal captures enum value "local"
	BackendLoadServerStateFromFileLocal string = "local"

	// BackendLoadServerStateFromFileNone captures enum value "none"
	BackendLoadServerStateFromFileNone string = "none"
)
View Source 
const (

	// BackendLogHealthChecksEnabled captures enum value "enabled"
	BackendLogHealthChecksEnabled string = "enabled"

	// BackendLogHealthChecksDisabled captures enum value "disabled"
	BackendLogHealthChecksDisabled string = "disabled"
)
View Source 
const (

	// BackendModeHTTP captures enum value "http"
	BackendModeHTTP string = "http"

	// BackendModeTCP captures enum value "tcp"
	BackendModeTCP string = "tcp"

	// BackendModeLog captures enum value "log"
	BackendModeLog string = "log"
)
View Source 
const (

	// BackendNolingerEnabled captures enum value "enabled"
	BackendNolingerEnabled string = "enabled"

	// BackendNolingerDisabled captures enum value "disabled"
	BackendNolingerDisabled string = "disabled"
)
View Source 
const (

	// BackendPersistEnabled captures enum value "enabled"
	BackendPersistEnabled string = "enabled"

	// BackendPersistDisabled captures enum value "disabled"
	BackendPersistDisabled string = "disabled"
)
View Source 
const (

	// BackendPreferLastServerEnabled captures enum value "enabled"
	BackendPreferLastServerEnabled string = "enabled"

	// BackendPreferLastServerDisabled captures enum value "disabled"
	BackendPreferLastServerDisabled string = "disabled"
)
View Source 
const (

	// BackendSpliceAutoEnabled captures enum value "enabled"
	BackendSpliceAutoEnabled string = "enabled"

	// BackendSpliceAutoDisabled captures enum value "disabled"
	BackendSpliceAutoDisabled string = "disabled"
)
View Source 
const (

	// BackendSpliceRequestEnabled captures enum value "enabled"
	BackendSpliceRequestEnabled string = "enabled"

	// BackendSpliceRequestDisabled captures enum value "disabled"
	BackendSpliceRequestDisabled string = "disabled"
)
View Source 
const (

	// BackendSpliceResponseEnabled captures enum value "enabled"
	BackendSpliceResponseEnabled string = "enabled"

	// BackendSpliceResponseDisabled captures enum value "disabled"
	BackendSpliceResponseDisabled string = "disabled"
)
View Source 
const (

	// BackendSpopCheckEnabled captures enum value "enabled"
	BackendSpopCheckEnabled string = "enabled"

	// BackendSpopCheckDisabled captures enum value "disabled"
	BackendSpopCheckDisabled string = "disabled"
)
View Source 
const (

	// BackendSrvtcpkaEnabled captures enum value "enabled"
	BackendSrvtcpkaEnabled string = "enabled"

	// BackendSrvtcpkaDisabled captures enum value "disabled"
	BackendSrvtcpkaDisabled string = "disabled"
)
View Source 
const (

	// BackendTCPSmartConnectEnabled captures enum value "enabled"
	BackendTCPSmartConnectEnabled string = "enabled"

	// BackendTCPSmartConnectDisabled captures enum value "disabled"
	BackendTCPSmartConnectDisabled string = "disabled"
)
View Source 
const (

	// BackendTcpkaEnabled captures enum value "enabled"
	BackendTcpkaEnabled string = "enabled"

	// BackendTcpkaDisabled captures enum value "disabled"
	BackendTcpkaDisabled string = "disabled"
)
View Source 
const (

	// BackendTransparentEnabled captures enum value "enabled"
	BackendTransparentEnabled string = "enabled"

	// BackendTransparentDisabled captures enum value "disabled"
	BackendTransparentDisabled string = "disabled"
)
View Source 
const (

	// BackendForcePersistCondIf captures enum value "if"
	BackendForcePersistCondIf string = "if"

	// BackendForcePersistCondUnless captures enum value "unless"
	BackendForcePersistCondUnless string = "unless"
)
View Source 
const (

	// ForcePersistCondIf captures enum value "if"
	ForcePersistCondIf string = "if"

	// ForcePersistCondUnless captures enum value "unless"
	ForcePersistCondUnless string = "unless"
)
View Source 
const (

	// BackendIgnorePersistCondIf captures enum value "if"
	BackendIgnorePersistCondIf string = "if"

	// BackendIgnorePersistCondUnless captures enum value "unless"
	BackendIgnorePersistCondUnless string = "unless"
)
View Source 
const (

	// IgnorePersistCondIf captures enum value "if"
	IgnorePersistCondIf string = "if"

	// IgnorePersistCondUnless captures enum value "unless"
	IgnorePersistCondUnless string = "unless"
)
View Source 
const (

	// BackendSwitchingRuleCondIf captures enum value "if"
	BackendSwitchingRuleCondIf string = "if"

	// BackendSwitchingRuleCondUnless captures enum value "unless"
	BackendSwitchingRuleCondUnless string = "unless"
)
View Source 
const (

	// BalanceAlgorithmFirst captures enum value "first"
	BalanceAlgorithmFirst string = "first"

	// BalanceAlgorithmHash captures enum value "hash"
	BalanceAlgorithmHash string = "hash"

	// BalanceAlgorithmHdr captures enum value "hdr"
	BalanceAlgorithmHdr string = "hdr"

	// BalanceAlgorithmLeastconn captures enum value "leastconn"
	BalanceAlgorithmLeastconn string = "leastconn"

	// BalanceAlgorithmRandom captures enum value "random"
	BalanceAlgorithmRandom string = "random"

	// BalanceAlgorithmRdpDashCookie captures enum value "rdp-cookie"
	BalanceAlgorithmRdpDashCookie string = "rdp-cookie"

	// BalanceAlgorithmRoundrobin captures enum value "roundrobin"
	BalanceAlgorithmRoundrobin string = "roundrobin"

	// BalanceAlgorithmSource captures enum value "source"
	BalanceAlgorithmSource string = "source"

	// BalanceAlgorithmStaticDashRr captures enum value "static-rr"
	BalanceAlgorithmStaticDashRr string = "static-rr"

	// BalanceAlgorithmURI captures enum value "uri"
	BalanceAlgorithmURI string = "uri"

	// BalanceAlgorithmURLParam captures enum value "url_param"
	BalanceAlgorithmURLParam string = "url_param"
)
View Source 
const (

	// BindParamsLevelUser captures enum value "user"
	BindParamsLevelUser string = "user"

	// BindParamsLevelOperator captures enum value "operator"
	BindParamsLevelOperator string = "operator"

	// BindParamsLevelAdmin captures enum value "admin"
	BindParamsLevelAdmin string = "admin"
)
View Source 
const (

	// BindParamsQuicCcAlgoCubic captures enum value "cubic"
	BindParamsQuicCcAlgoCubic string = "cubic"

	// BindParamsQuicCcAlgoNewreno captures enum value "newreno"
	BindParamsQuicCcAlgoNewreno string = "newreno"
)
View Source 
const (

	// BindParamsQuicSocketConnection captures enum value "connection"
	BindParamsQuicSocketConnection string = "connection"

	// BindParamsQuicSocketListener captures enum value "listener"
	BindParamsQuicSocketListener string = "listener"
)
View Source 
const (

	// BindParamsSeverityOutputNone captures enum value "none"
	BindParamsSeverityOutputNone string = "none"

	// BindParamsSeverityOutputNumber captures enum value "number"
	BindParamsSeverityOutputNumber string = "number"

	// BindParamsSeverityOutputString captures enum value "string"
	BindParamsSeverityOutputString string = "string"
)
View Source 
const (

	// BindParamsSslMaxVerSSLv3 captures enum value "SSLv3"
	BindParamsSslMaxVerSSLv3 string = "SSLv3"

	// BindParamsSslMaxVerTLSv1Dot0 captures enum value "TLSv1.0"
	BindParamsSslMaxVerTLSv1Dot0 string = "TLSv1.0"

	// BindParamsSslMaxVerTLSv1Dot1 captures enum value "TLSv1.1"
	BindParamsSslMaxVerTLSv1Dot1 string = "TLSv1.1"

	// BindParamsSslMaxVerTLSv1Dot2 captures enum value "TLSv1.2"
	BindParamsSslMaxVerTLSv1Dot2 string = "TLSv1.2"

	// BindParamsSslMaxVerTLSv1Dot3 captures enum value "TLSv1.3"
	BindParamsSslMaxVerTLSv1Dot3 string = "TLSv1.3"
)
View Source 
const (

	// BindParamsSslMinVerSSLv3 captures enum value "SSLv3"
	BindParamsSslMinVerSSLv3 string = "SSLv3"

	// BindParamsSslMinVerTLSv1Dot0 captures enum value "TLSv1.0"
	BindParamsSslMinVerTLSv1Dot0 string = "TLSv1.0"

	// BindParamsSslMinVerTLSv1Dot1 captures enum value "TLSv1.1"
	BindParamsSslMinVerTLSv1Dot1 string = "TLSv1.1"

	// BindParamsSslMinVerTLSv1Dot2 captures enum value "TLSv1.2"
	BindParamsSslMinVerTLSv1Dot2 string = "TLSv1.2"

	// BindParamsSslMinVerTLSv1Dot3 captures enum value "TLSv1.3"
	BindParamsSslMinVerTLSv1Dot3 string = "TLSv1.3"
)
View Source 
const (

	// BindParamsVerifyNone captures enum value "none"
	BindParamsVerifyNone string = "none"

	// BindParamsVerifyOptional captures enum value "optional"
	BindParamsVerifyOptional string = "optional"

	// BindParamsVerifyRequired captures enum value "required"
	BindParamsVerifyRequired string = "required"
)
View Source 
const (

	// CaptureTypeRequest captures enum value "request"
	CaptureTypeRequest string = "request"

	// CaptureTypeResponse captures enum value "response"
	CaptureTypeResponse string = "response"
)
View Source 
const (

	// ClusterSettingsModeSingle captures enum value "single"
	ClusterSettingsModeSingle string = "single"

	// ClusterSettingsModeCluster captures enum value "cluster"
	ClusterSettingsModeCluster string = "cluster"
)
View Source 
const (

	// ClusterSettingsStatusActive captures enum value "active"
	ClusterSettingsStatusActive string = "active"

	// ClusterSettingsStatusUnreachable captures enum value "unreachable"
	ClusterSettingsStatusUnreachable string = "unreachable"

	// ClusterSettingsStatusWaitingApproval captures enum value "waiting_approval"
	ClusterSettingsStatusWaitingApproval string = "waiting_approval"
)
View Source 
const (

	// ClusterLogTargetProtocolTCP captures enum value "tcp"
	ClusterLogTargetProtocolTCP string = "tcp"

	// ClusterLogTargetProtocolUDP captures enum value "udp"
	ClusterLogTargetProtocolUDP string = "udp"
)
View Source 
const (

	// CompressionAlgoReqIdentity captures enum value "identity"
	CompressionAlgoReqIdentity string = "identity"

	// CompressionAlgoReqGzip captures enum value "gzip"
	CompressionAlgoReqGzip string = "gzip"

	// CompressionAlgoReqDeflate captures enum value "deflate"
	CompressionAlgoReqDeflate string = "deflate"

	// CompressionAlgoReqRawDashDeflate captures enum value "raw-deflate"
	CompressionAlgoReqRawDashDeflate string = "raw-deflate"
)
View Source 
const (

	// CompressionDirectionRequest captures enum value "request"
	CompressionDirectionRequest string = "request"

	// CompressionDirectionResponse captures enum value "response"
	CompressionDirectionResponse string = "response"

	// CompressionDirectionBoth captures enum value "both"
	CompressionDirectionBoth string = "both"
)
View Source 
const (

	// ConfigStickTableSrvkeyAddr captures enum value "addr"
	ConfigStickTableSrvkeyAddr string = "addr"

	// ConfigStickTableSrvkeyName captures enum value "name"
	ConfigStickTableSrvkeyName string = "name"
)
View Source 
const (

	// ConfigStickTableTypeIP captures enum value "ip"
	ConfigStickTableTypeIP string = "ip"

	// ConfigStickTableTypeIPV6 captures enum value "ipv6"
	ConfigStickTableTypeIPV6 string = "ipv6"

	// ConfigStickTableTypeInteger captures enum value "integer"
	ConfigStickTableTypeInteger string = "integer"

	// ConfigStickTableTypeString captures enum value "string"
	ConfigStickTableTypeString string = "string"

	// ConfigStickTableTypeBinary captures enum value "binary"
	ConfigStickTableTypeBinary string = "binary"
)
View Source 
const (

	// ConsulHealthCheckPolicyNone captures enum value "none"
	ConsulHealthCheckPolicyNone string = "none"

	// ConsulHealthCheckPolicyAny captures enum value "any"
	ConsulHealthCheckPolicyAny string = "any"

	// ConsulHealthCheckPolicyAll captures enum value "all"
	ConsulHealthCheckPolicyAll string = "all"

	// ConsulHealthCheckPolicyMin captures enum value "min"
	ConsulHealthCheckPolicyMin string = "min"
)
View Source 
const (

	// ConsulModeHTTP captures enum value "http"
	ConsulModeHTTP string = "http"

	// ConsulModeHTTPS captures enum value "https"
	ConsulModeHTTPS string = "https"
)
View Source 
const (

	// ConsulServerSlotsGrowthTypeLinear captures enum value "linear"
	ConsulServerSlotsGrowthTypeLinear string = "linear"

	// ConsulServerSlotsGrowthTypeExponential captures enum value "exponential"
	ConsulServerSlotsGrowthTypeExponential string = "exponential"
)
View Source 
const (

	// CookieTypeRewrite captures enum value "rewrite"
	CookieTypeRewrite string = "rewrite"

	// CookieTypeInsert captures enum value "insert"
	CookieTypeInsert string = "insert"

	// CookieTypePrefix captures enum value "prefix"
	CookieTypePrefix string = "prefix"
)
View Source 
const (

	// DefaultsAbortoncloseEnabled captures enum value "enabled"
	DefaultsAbortoncloseEnabled string = "enabled"

	// DefaultsAbortoncloseDisabled captures enum value "disabled"
	DefaultsAbortoncloseDisabled string = "disabled"
)
View Source 
const (

	// DefaultsAcceptInvalidHTTPRequestEnabled captures enum value "enabled"
	DefaultsAcceptInvalidHTTPRequestEnabled string = "enabled"

	// DefaultsAcceptInvalidHTTPRequestDisabled captures enum value "disabled"
	DefaultsAcceptInvalidHTTPRequestDisabled string = "disabled"
)
View Source 
const (

	// DefaultsAcceptInvalidHTTPResponseEnabled captures enum value "enabled"
	DefaultsAcceptInvalidHTTPResponseEnabled string = "enabled"

	// DefaultsAcceptInvalidHTTPResponseDisabled captures enum value "disabled"
	DefaultsAcceptInvalidHTTPResponseDisabled string = "disabled"
)
View Source 
const (

	// DefaultsAdvCheckHttpchk captures enum value "httpchk"
	DefaultsAdvCheckHttpchk string = "httpchk"

	// DefaultsAdvCheckLdapDashCheck captures enum value "ldap-check"
	DefaultsAdvCheckLdapDashCheck string = "ldap-check"

	// DefaultsAdvCheckMysqlDashCheck captures enum value "mysql-check"
	DefaultsAdvCheckMysqlDashCheck string = "mysql-check"

	// DefaultsAdvCheckPgsqlDashCheck captures enum value "pgsql-check"
	DefaultsAdvCheckPgsqlDashCheck string = "pgsql-check"

	// DefaultsAdvCheckRedisDashCheck captures enum value "redis-check"
	DefaultsAdvCheckRedisDashCheck string = "redis-check"

	// DefaultsAdvCheckSmtpchk captures enum value "smtpchk"
	DefaultsAdvCheckSmtpchk string = "smtpchk"

	// DefaultsAdvCheckSslDashHelloDashChk captures enum value "ssl-hello-chk"
	DefaultsAdvCheckSslDashHelloDashChk string = "ssl-hello-chk"

	// DefaultsAdvCheckTCPDashCheck captures enum value "tcp-check"
	DefaultsAdvCheckTCPDashCheck string = "tcp-check"
)
View Source 
const (

	// DefaultsAllbackupsEnabled captures enum value "enabled"
	DefaultsAllbackupsEnabled string = "enabled"

	// DefaultsAllbackupsDisabled captures enum value "disabled"
	DefaultsAllbackupsDisabled string = "disabled"
)
View Source 
const (

	// DefaultsCheckcacheEnabled captures enum value "enabled"
	DefaultsCheckcacheEnabled string = "enabled"

	// DefaultsCheckcacheDisabled captures enum value "disabled"
	DefaultsCheckcacheDisabled string = "disabled"
)
View Source 
const (

	// DefaultsClitcpkaEnabled captures enum value "enabled"
	DefaultsClitcpkaEnabled string = "enabled"

	// DefaultsClitcpkaDisabled captures enum value "disabled"
	DefaultsClitcpkaDisabled string = "disabled"
)
View Source 
const (

	// DefaultsDisableH2UpgradeEnabled captures enum value "enabled"
	DefaultsDisableH2UpgradeEnabled string = "enabled"

	// DefaultsDisableH2UpgradeDisabled captures enum value "disabled"
	DefaultsDisableH2UpgradeDisabled string = "disabled"
)
View Source 
const (

	// DefaultsDontlogNormalEnabled captures enum value "enabled"
	DefaultsDontlogNormalEnabled string = "enabled"

	// DefaultsDontlogNormalDisabled captures enum value "disabled"
	DefaultsDontlogNormalDisabled string = "disabled"
)
View Source 
const (

	// DefaultsDontlognullEnabled captures enum value "enabled"
	DefaultsDontlognullEnabled string = "enabled"

	// DefaultsDontlognullDisabled captures enum value "disabled"
	DefaultsDontlognullDisabled string = "disabled"
)
View Source 
const (

	// DefaultsExternalCheckEnabled captures enum value "enabled"
	DefaultsExternalCheckEnabled string = "enabled"

	// DefaultsExternalCheckDisabled captures enum value "disabled"
	DefaultsExternalCheckDisabled string = "disabled"
)
View Source 
const (

	// DefaultsH1CaseAdjustBogusClientEnabled captures enum value "enabled"
	DefaultsH1CaseAdjustBogusClientEnabled string = "enabled"

	// DefaultsH1CaseAdjustBogusClientDisabled captures enum value "disabled"
	DefaultsH1CaseAdjustBogusClientDisabled string = "disabled"
)
View Source 
const (

	// DefaultsH1CaseAdjustBogusServerEnabled captures enum value "enabled"
	DefaultsH1CaseAdjustBogusServerEnabled string = "enabled"

	// DefaultsH1CaseAdjustBogusServerDisabled captures enum value "disabled"
	DefaultsH1CaseAdjustBogusServerDisabled string = "disabled"
)
View Source 
const (

	// DefaultsHTTPBufferRequestEnabled captures enum value "enabled"
	DefaultsHTTPBufferRequestEnabled string = "enabled"

	// DefaultsHTTPBufferRequestDisabled captures enum value "disabled"
	DefaultsHTTPBufferRequestDisabled string = "disabled"
)
View Source 
const (

	// DefaultsHTTPUseHtxEnabled captures enum value "enabled"
	DefaultsHTTPUseHtxEnabled string = "enabled"

	// DefaultsHTTPUseHtxDisabled captures enum value "disabled"
	DefaultsHTTPUseHtxDisabled string = "disabled"
)
View Source 
const (

	// DefaultsHTTPConnectionModeHttpclose captures enum value "httpclose"
	DefaultsHTTPConnectionModeHttpclose string = "httpclose"

	// DefaultsHTTPConnectionModeHTTPDashServerDashClose captures enum value "http-server-close"
	DefaultsHTTPConnectionModeHTTPDashServerDashClose string = "http-server-close"

	// DefaultsHTTPConnectionModeHTTPDashKeepDashAlive captures enum value "http-keep-alive"
	DefaultsHTTPConnectionModeHTTPDashKeepDashAlive string = "http-keep-alive"
)
View Source 
const (

	// DefaultsHTTPIgnoreProbesEnabled captures enum value "enabled"
	DefaultsHTTPIgnoreProbesEnabled string = "enabled"

	// DefaultsHTTPIgnoreProbesDisabled captures enum value "disabled"
	DefaultsHTTPIgnoreProbesDisabled string = "disabled"
)
View Source 
const (

	// DefaultsHTTPNoDelayEnabled captures enum value "enabled"
	DefaultsHTTPNoDelayEnabled string = "enabled"

	// DefaultsHTTPNoDelayDisabled captures enum value "disabled"
	DefaultsHTTPNoDelayDisabled string = "disabled"
)
View Source 
const (

	// DefaultsHTTPPretendKeepaliveEnabled captures enum value "enabled"
	DefaultsHTTPPretendKeepaliveEnabled string = "enabled"

	// DefaultsHTTPPretendKeepaliveDisabled captures enum value "disabled"
	DefaultsHTTPPretendKeepaliveDisabled string = "disabled"
)
View Source 
const (

	// DefaultsHTTPRestrictReqHdrNamesPreserve captures enum value "preserve"
	DefaultsHTTPRestrictReqHdrNamesPreserve string = "preserve"

	// DefaultsHTTPRestrictReqHdrNamesDelete captures enum value "delete"
	DefaultsHTTPRestrictReqHdrNamesDelete string = "delete"

	// DefaultsHTTPRestrictReqHdrNamesReject captures enum value "reject"
	DefaultsHTTPRestrictReqHdrNamesReject string = "reject"
)
View Source 
const (

	// DefaultsHTTPReuseAggressive captures enum value "aggressive"
	DefaultsHTTPReuseAggressive string = "aggressive"

	// DefaultsHTTPReuseAlways captures enum value "always"
	DefaultsHTTPReuseAlways string = "always"

	// DefaultsHTTPReuseNever captures enum value "never"
	DefaultsHTTPReuseNever string = "never"

	// DefaultsHTTPReuseSafe captures enum value "safe"
	DefaultsHTTPReuseSafe string = "safe"
)
View Source 
const (

	// DefaultsHTTPUseProxyHeaderEnabled captures enum value "enabled"
	DefaultsHTTPUseProxyHeaderEnabled string = "enabled"

	// DefaultsHTTPUseProxyHeaderDisabled captures enum value "disabled"
	DefaultsHTTPUseProxyHeaderDisabled string = "disabled"
)
View Source 
const (

	// DefaultsHttpslogEnabled captures enum value "enabled"
	DefaultsHttpslogEnabled string = "enabled"

	// DefaultsHttpslogDisabled captures enum value "disabled"
	DefaultsHttpslogDisabled string = "disabled"
)
View Source 
const (

	// DefaultsIdleCloseOnResponseEnabled captures enum value "enabled"
	DefaultsIdleCloseOnResponseEnabled string = "enabled"

	// DefaultsIdleCloseOnResponseDisabled captures enum value "disabled"
	DefaultsIdleCloseOnResponseDisabled string = "disabled"
)
View Source 
const (

	// DefaultsIndependentStreamsEnabled captures enum value "enabled"
	DefaultsIndependentStreamsEnabled string = "enabled"

	// DefaultsIndependentStreamsDisabled captures enum value "disabled"
	DefaultsIndependentStreamsDisabled string = "disabled"
)
View Source 
const (

	// DefaultsLoadServerStateFromFileGlobal captures enum value "global"
	DefaultsLoadServerStateFromFileGlobal string = "global"

	// DefaultsLoadServerStateFromFileLocal captures enum value "local"
	DefaultsLoadServerStateFromFileLocal string = "local"

	// DefaultsLoadServerStateFromFileNone captures enum value "none"
	DefaultsLoadServerStateFromFileNone string = "none"
)
View Source 
const (

	// DefaultsLogHealthChecksEnabled captures enum value "enabled"
	DefaultsLogHealthChecksEnabled string = "enabled"

	// DefaultsLogHealthChecksDisabled captures enum value "disabled"
	DefaultsLogHealthChecksDisabled string = "disabled"
)
View Source 
const (

	// DefaultsLogSeparateErrorsEnabled captures enum value "enabled"
	DefaultsLogSeparateErrorsEnabled string = "enabled"

	// DefaultsLogSeparateErrorsDisabled captures enum value "disabled"
	DefaultsLogSeparateErrorsDisabled string = "disabled"
)
View Source 
const (

	// DefaultsLogasapEnabled captures enum value "enabled"
	DefaultsLogasapEnabled string = "enabled"

	// DefaultsLogasapDisabled captures enum value "disabled"
	DefaultsLogasapDisabled string = "disabled"
)
View Source 
const (

	// DefaultsModeTCP captures enum value "tcp"
	DefaultsModeTCP string = "tcp"

	// DefaultsModeHTTP captures enum value "http"
	DefaultsModeHTTP string = "http"

	// DefaultsModeLog captures enum value "log"
	DefaultsModeLog string = "log"
)
View Source 
const (

	// DefaultsNolingerEnabled captures enum value "enabled"
	DefaultsNolingerEnabled string = "enabled"

	// DefaultsNolingerDisabled captures enum value "disabled"
	DefaultsNolingerDisabled string = "disabled"
)
View Source 
const (

	// DefaultsPersistEnabled captures enum value "enabled"
	DefaultsPersistEnabled string = "enabled"

	// DefaultsPersistDisabled captures enum value "disabled"
	DefaultsPersistDisabled string = "disabled"
)
View Source 
const (

	// DefaultsPreferLastServerEnabled captures enum value "enabled"
	DefaultsPreferLastServerEnabled string = "enabled"

	// DefaultsPreferLastServerDisabled captures enum value "disabled"
	DefaultsPreferLastServerDisabled string = "disabled"
)
View Source 
const (

	// DefaultsSocketStatsEnabled captures enum value "enabled"
	DefaultsSocketStatsEnabled string = "enabled"

	// DefaultsSocketStatsDisabled captures enum value "disabled"
	DefaultsSocketStatsDisabled string = "disabled"
)
View Source 
const (

	// DefaultsSpliceAutoEnabled captures enum value "enabled"
	DefaultsSpliceAutoEnabled string = "enabled"

	// DefaultsSpliceAutoDisabled captures enum value "disabled"
	DefaultsSpliceAutoDisabled string = "disabled"
)
View Source 
const (

	// DefaultsSpliceRequestEnabled captures enum value "enabled"
	DefaultsSpliceRequestEnabled string = "enabled"

	// DefaultsSpliceRequestDisabled captures enum value "disabled"
	DefaultsSpliceRequestDisabled string = "disabled"
)
View Source 
const (

	// DefaultsSpliceResponseEnabled captures enum value "enabled"
	DefaultsSpliceResponseEnabled string = "enabled"

	// DefaultsSpliceResponseDisabled captures enum value "disabled"
	DefaultsSpliceResponseDisabled string = "disabled"
)
View Source 
const (

	// DefaultsSrvtcpkaEnabled captures enum value "enabled"
	DefaultsSrvtcpkaEnabled string = "enabled"

	// DefaultsSrvtcpkaDisabled captures enum value "disabled"
	DefaultsSrvtcpkaDisabled string = "disabled"
)
View Source 
const (

	// DefaultsTCPSmartAcceptEnabled captures enum value "enabled"
	DefaultsTCPSmartAcceptEnabled string = "enabled"

	// DefaultsTCPSmartAcceptDisabled captures enum value "disabled"
	DefaultsTCPSmartAcceptDisabled string = "disabled"
)
View Source 
const (

	// DefaultsTCPSmartConnectEnabled captures enum value "enabled"
	DefaultsTCPSmartConnectEnabled string = "enabled"

	// DefaultsTCPSmartConnectDisabled captures enum value "disabled"
	DefaultsTCPSmartConnectDisabled string = "disabled"
)
View Source 
const (

	// DefaultsTcpkaEnabled captures enum value "enabled"
	DefaultsTcpkaEnabled string = "enabled"

	// DefaultsTcpkaDisabled captures enum value "disabled"
	DefaultsTcpkaDisabled string = "disabled"
)
View Source 
const (

	// DefaultsTransparentEnabled captures enum value "enabled"
	DefaultsTransparentEnabled string = "enabled"

	// DefaultsTransparentDisabled captures enum value "disabled"
	DefaultsTransparentDisabled string = "disabled"
)
View Source 
const (

	// EmailAlertLevelEmerg captures enum value "emerg"
	EmailAlertLevelEmerg string = "emerg"

	// EmailAlertLevelAlert captures enum value "alert"
	EmailAlertLevelAlert string = "alert"

	// EmailAlertLevelCrit captures enum value "crit"
	EmailAlertLevelCrit string = "crit"

	// EmailAlertLevelErr captures enum value "err"
	EmailAlertLevelErr string = "err"

	// EmailAlertLevelWarning captures enum value "warning"
	EmailAlertLevelWarning string = "warning"

	// EmailAlertLevelNotice captures enum value "notice"
	EmailAlertLevelNotice string = "notice"

	// EmailAlertLevelInfo captures enum value "info"
	EmailAlertLevelInfo string = "info"

	// EmailAlertLevelDebug captures enum value "debug"
	EmailAlertLevelDebug string = "debug"
)
View Source 
const (

	// FCGIAppGetValuesEnabled captures enum value "enabled"
	FCGIAppGetValuesEnabled string = "enabled"

	// FCGIAppGetValuesDisabled captures enum value "disabled"
	FCGIAppGetValuesDisabled string = "disabled"
)
View Source 
const (

	// FCGIAppKeepConnEnabled captures enum value "enabled"
	FCGIAppKeepConnEnabled string = "enabled"

	// FCGIAppKeepConnDisabled captures enum value "disabled"
	FCGIAppKeepConnDisabled string = "disabled"
)
View Source 
const (

	// FCGIAppMpxsConnsEnabled captures enum value "enabled"
	FCGIAppMpxsConnsEnabled string = "enabled"

	// FCGIAppMpxsConnsDisabled captures enum value "disabled"
	FCGIAppMpxsConnsDisabled string = "disabled"
)
View Source 
const (

	// FCGIPassHeaderCondIf captures enum value "if"
	FCGIPassHeaderCondIf string = "if"

	// FCGIPassHeaderCondUnless captures enum value "unless"
	FCGIPassHeaderCondUnless string = "unless"
)
View Source 
const (

	// FCGISetParamCondIf captures enum value "if"
	FCGISetParamCondIf string = "if"

	// FCGISetParamCondUnless captures enum value "unless"
	FCGISetParamCondUnless string = "unless"
)
View Source 
const (

	// FilterTypeBwlimDashIn captures enum value "bwlim-in"
	FilterTypeBwlimDashIn string = "bwlim-in"

	// FilterTypeBwlimDashOut captures enum value "bwlim-out"
	FilterTypeBwlimDashOut string = "bwlim-out"

	// FilterTypeCache captures enum value "cache"
	FilterTypeCache string = "cache"

	// FilterTypeCompression captures enum value "compression"
	FilterTypeCompression string = "compression"

	// FilterTypeFCGIDashApp captures enum value "fcgi-app"
	FilterTypeFCGIDashApp string = "fcgi-app"

	// FilterTypeSpoe captures enum value "spoe"
	FilterTypeSpoe string = "spoe"

	// FilterTypeTrace captures enum value "trace"
	FilterTypeTrace string = "trace"
)
View Source 
const (

	// FrontendAcceptInvalidHTTPRequestEnabled captures enum value "enabled"
	FrontendAcceptInvalidHTTPRequestEnabled string = "enabled"

	// FrontendAcceptInvalidHTTPRequestDisabled captures enum value "disabled"
	FrontendAcceptInvalidHTTPRequestDisabled string = "disabled"
)
View Source 
const (

	// FrontendClitcpkaEnabled captures enum value "enabled"
	FrontendClitcpkaEnabled string = "enabled"

	// FrontendClitcpkaDisabled captures enum value "disabled"
	FrontendClitcpkaDisabled string = "disabled"
)
View Source 
const (

	// FrontendDisableH2UpgradeEnabled captures enum value "enabled"
	FrontendDisableH2UpgradeEnabled string = "enabled"

	// FrontendDisableH2UpgradeDisabled captures enum value "disabled"
	FrontendDisableH2UpgradeDisabled string = "disabled"
)
View Source 
const (

	// FrontendDontlogNormalEnabled captures enum value "enabled"
	FrontendDontlogNormalEnabled string = "enabled"

	// FrontendDontlogNormalDisabled captures enum value "disabled"
	FrontendDontlogNormalDisabled string = "disabled"
)
View Source 
const (

	// FrontendDontlognullEnabled captures enum value "enabled"
	FrontendDontlognullEnabled string = "enabled"

	// FrontendDontlognullDisabled captures enum value "disabled"
	FrontendDontlognullDisabled string = "disabled"
)
View Source 
const (

	// FrontendH1CaseAdjustBogusClientEnabled captures enum value "enabled"
	FrontendH1CaseAdjustBogusClientEnabled string = "enabled"

	// FrontendH1CaseAdjustBogusClientDisabled captures enum value "disabled"
	FrontendH1CaseAdjustBogusClientDisabled string = "disabled"
)
View Source 
const (

	// FrontendHTTPBufferRequestEnabled captures enum value "enabled"
	FrontendHTTPBufferRequestEnabled string = "enabled"

	// FrontendHTTPBufferRequestDisabled captures enum value "disabled"
	FrontendHTTPBufferRequestDisabled string = "disabled"
)
View Source 
const (

	// FrontendHTTPUseHtxEnabled captures enum value "enabled"
	FrontendHTTPUseHtxEnabled string = "enabled"

	// FrontendHTTPUseHtxDisabled captures enum value "disabled"
	FrontendHTTPUseHtxDisabled string = "disabled"
)
View Source 
const (

	// FrontendHTTPConnectionModeHttpclose captures enum value "httpclose"
	FrontendHTTPConnectionModeHttpclose string = "httpclose"

	// FrontendHTTPConnectionModeHTTPDashServerDashClose captures enum value "http-server-close"
	FrontendHTTPConnectionModeHTTPDashServerDashClose string = "http-server-close"

	// FrontendHTTPConnectionModeHTTPDashKeepDashAlive captures enum value "http-keep-alive"
	FrontendHTTPConnectionModeHTTPDashKeepDashAlive string = "http-keep-alive"
)
View Source 
const (

	// FrontendHTTPIgnoreProbesEnabled captures enum value "enabled"
	FrontendHTTPIgnoreProbesEnabled string = "enabled"

	// FrontendHTTPIgnoreProbesDisabled captures enum value "disabled"
	FrontendHTTPIgnoreProbesDisabled string = "disabled"
)
View Source 
const (

	// FrontendHTTPNoDelayEnabled captures enum value "enabled"
	FrontendHTTPNoDelayEnabled string = "enabled"

	// FrontendHTTPNoDelayDisabled captures enum value "disabled"
	FrontendHTTPNoDelayDisabled string = "disabled"
)
View Source 
const (

	// FrontendHTTPRestrictReqHdrNamesPreserve captures enum value "preserve"
	FrontendHTTPRestrictReqHdrNamesPreserve string = "preserve"

	// FrontendHTTPRestrictReqHdrNamesDelete captures enum value "delete"
	FrontendHTTPRestrictReqHdrNamesDelete string = "delete"

	// FrontendHTTPRestrictReqHdrNamesReject captures enum value "reject"
	FrontendHTTPRestrictReqHdrNamesReject string = "reject"
)
View Source 
const (

	// FrontendHTTPUseProxyHeaderEnabled captures enum value "enabled"
	FrontendHTTPUseProxyHeaderEnabled string = "enabled"

	// FrontendHTTPUseProxyHeaderDisabled captures enum value "disabled"
	FrontendHTTPUseProxyHeaderDisabled string = "disabled"
)
View Source 
const (

	// FrontendHttpslogEnabled captures enum value "enabled"
	FrontendHttpslogEnabled string = "enabled"

	// FrontendHttpslogDisabled captures enum value "disabled"
	FrontendHttpslogDisabled string = "disabled"
)
View Source 
const (

	// FrontendIdleCloseOnResponseEnabled captures enum value "enabled"
	FrontendIdleCloseOnResponseEnabled string = "enabled"

	// FrontendIdleCloseOnResponseDisabled captures enum value "disabled"
	FrontendIdleCloseOnResponseDisabled string = "disabled"
)
View Source 
const (

	// FrontendIndependentStreamsEnabled captures enum value "enabled"
	FrontendIndependentStreamsEnabled string = "enabled"

	// FrontendIndependentStreamsDisabled captures enum value "disabled"
	FrontendIndependentStreamsDisabled string = "disabled"
)
View Source 
const (

	// FrontendLogSeparateErrorsEnabled captures enum value "enabled"
	FrontendLogSeparateErrorsEnabled string = "enabled"

	// FrontendLogSeparateErrorsDisabled captures enum value "disabled"
	FrontendLogSeparateErrorsDisabled string = "disabled"
)
View Source 
const (

	// FrontendLogasapEnabled captures enum value "enabled"
	FrontendLogasapEnabled string = "enabled"

	// FrontendLogasapDisabled captures enum value "disabled"
	FrontendLogasapDisabled string = "disabled"
)
View Source 
const (

	// FrontendModeHTTP captures enum value "http"
	FrontendModeHTTP string = "http"

	// FrontendModeTCP captures enum value "tcp"
	FrontendModeTCP string = "tcp"
)
View Source 
const (

	// FrontendNolingerEnabled captures enum value "enabled"
	FrontendNolingerEnabled string = "enabled"

	// FrontendNolingerDisabled captures enum value "disabled"
	FrontendNolingerDisabled string = "disabled"
)
View Source 
const (

	// FrontendSocketStatsEnabled captures enum value "enabled"
	FrontendSocketStatsEnabled string = "enabled"

	// FrontendSocketStatsDisabled captures enum value "disabled"
	FrontendSocketStatsDisabled string = "disabled"
)
View Source 
const (

	// FrontendSpliceAutoEnabled captures enum value "enabled"
	FrontendSpliceAutoEnabled string = "enabled"

	// FrontendSpliceAutoDisabled captures enum value "disabled"
	FrontendSpliceAutoDisabled string = "disabled"
)
View Source 
const (

	// FrontendSpliceRequestEnabled captures enum value "enabled"
	FrontendSpliceRequestEnabled string = "enabled"

	// FrontendSpliceRequestDisabled captures enum value "disabled"
	FrontendSpliceRequestDisabled string = "disabled"
)
View Source 
const (

	// FrontendSpliceResponseEnabled captures enum value "enabled"
	FrontendSpliceResponseEnabled string = "enabled"

	// FrontendSpliceResponseDisabled captures enum value "disabled"
	FrontendSpliceResponseDisabled string = "disabled"
)
View Source 
const (

	// FrontendTCPSmartAcceptEnabled captures enum value "enabled"
	FrontendTCPSmartAcceptEnabled string = "enabled"

	// FrontendTCPSmartAcceptDisabled captures enum value "disabled"
	FrontendTCPSmartAcceptDisabled string = "disabled"
)
View Source 
const (

	// FrontendTcpkaEnabled captures enum value "enabled"
	FrontendTcpkaEnabled string = "enabled"

	// FrontendTcpkaDisabled captures enum value "disabled"
	FrontendTcpkaDisabled string = "disabled"
)
View Source 
const (

	// GlobalDaemonEnabled captures enum value "enabled"
	GlobalDaemonEnabled string = "enabled"

	// GlobalDaemonDisabled captures enum value "disabled"
	GlobalDaemonDisabled string = "disabled"
)
View Source 
const (

	// GlobalHttpclientResolversDisabledEnabled captures enum value "enabled"
	GlobalHttpclientResolversDisabledEnabled string = "enabled"

	// GlobalHttpclientResolversDisabledDisabled captures enum value "disabled"
	GlobalHttpclientResolversDisabledDisabled string = "disabled"
)
View Source 
const (

	// GlobalHttpclientResolversPreferIPV4 captures enum value "ipv4"
	GlobalHttpclientResolversPreferIPV4 string = "ipv4"

	// GlobalHttpclientResolversPreferIPV6 captures enum value "ipv6"
	GlobalHttpclientResolversPreferIPV6 string = "ipv6"
)
View Source 
const (

	// GlobalHttpclientSslVerifyEmpty captures enum value ""
	GlobalHttpclientSslVerifyEmpty string = ""

	// GlobalHttpclientSslVerifyNone captures enum value "none"
	GlobalHttpclientSslVerifyNone string = "none"

	// GlobalHttpclientSslVerifyRequired captures enum value "required"
	GlobalHttpclientSslVerifyRequired string = "required"
)
View Source 
const (

	// GlobalLoadServerStateFromFileGlobal captures enum value "global"
	GlobalLoadServerStateFromFileGlobal string = "global"

	// GlobalLoadServerStateFromFileLocal captures enum value "local"
	GlobalLoadServerStateFromFileLocal string = "local"

	// GlobalLoadServerStateFromFileNone captures enum value "none"
	GlobalLoadServerStateFromFileNone string = "none"
)
View Source 
const (

	// GlobalNumaCPUMappingEnabled captures enum value "enabled"
	GlobalNumaCPUMappingEnabled string = "enabled"

	// GlobalNumaCPUMappingDisabled captures enum value "disabled"
	GlobalNumaCPUMappingDisabled string = "disabled"
)
View Source 
const (

	// GlobalProfilingTasksAuto captures enum value "auto"
	GlobalProfilingTasksAuto string = "auto"

	// GlobalProfilingTasksOn captures enum value "on"
	GlobalProfilingTasksOn string = "on"

	// GlobalProfilingTasksOff captures enum value "off"
	GlobalProfilingTasksOff string = "off"
)
View Source 
const (

	// GlobalSslModeAsyncEnabled captures enum value "enabled"
	GlobalSslModeAsyncEnabled string = "enabled"

	// GlobalSslModeAsyncDisabled captures enum value "disabled"
	GlobalSslModeAsyncDisabled string = "disabled"
)
View Source 
const (

	// GlobalSslServerVerifyNone captures enum value "none"
	GlobalSslServerVerifyNone string = "none"

	// GlobalSslServerVerifyRequired captures enum value "required"
	GlobalSslServerVerifyRequired string = "required"
)
View Source 
const (

	// GlobalDefaultPathTypeCurrent captures enum value "current"
	GlobalDefaultPathTypeCurrent string = "current"

	// GlobalDefaultPathTypeConfig captures enum value "config"
	GlobalDefaultPathTypeConfig string = "config"

	// GlobalDefaultPathTypeParent captures enum value "parent"
	GlobalDefaultPathTypeParent string = "parent"

	// GlobalDefaultPathTypeOrigin captures enum value "origin"
	GlobalDefaultPathTypeOrigin string = "origin"
)
View Source 
const (

	// GlobalLogSendHostnameEnabledEnabled captures enum value "enabled"
	GlobalLogSendHostnameEnabledEnabled string = "enabled"

	// GlobalLogSendHostnameEnabledDisabled captures enum value "disabled"
	GlobalLogSendHostnameEnabledDisabled string = "disabled"
)
View Source 
const (

	// LuaPrependPathTypePath captures enum value "path"
	LuaPrependPathTypePath string = "path"

	// LuaPrependPathTypeCpath captures enum value "cpath"
	LuaPrependPathTypeCpath string = "cpath"
)
View Source 
const (

	// GlobalTuneOptionsFdEdgeTriggeredEnabled captures enum value "enabled"
	GlobalTuneOptionsFdEdgeTriggeredEnabled string = "enabled"

	// GlobalTuneOptionsFdEdgeTriggeredDisabled captures enum value "disabled"
	GlobalTuneOptionsFdEdgeTriggeredDisabled string = "disabled"
)
View Source 
const (

	// GlobalTuneOptionsH1ZeroCopyFwdRecvEnabled captures enum value "enabled"
	GlobalTuneOptionsH1ZeroCopyFwdRecvEnabled string = "enabled"

	// GlobalTuneOptionsH1ZeroCopyFwdRecvDisabled captures enum value "disabled"
	GlobalTuneOptionsH1ZeroCopyFwdRecvDisabled string = "disabled"
)
View Source 
const (

	// GlobalTuneOptionsH1ZeroCopyFwdSendEnabled captures enum value "enabled"
	GlobalTuneOptionsH1ZeroCopyFwdSendEnabled string = "enabled"

	// GlobalTuneOptionsH1ZeroCopyFwdSendDisabled captures enum value "disabled"
	GlobalTuneOptionsH1ZeroCopyFwdSendDisabled string = "disabled"
)
View Source 
const (

	// GlobalTuneOptionsH2ZeroCopyFwdSendEnabled captures enum value "enabled"
	GlobalTuneOptionsH2ZeroCopyFwdSendEnabled string = "enabled"

	// GlobalTuneOptionsH2ZeroCopyFwdSendDisabled captures enum value "disabled"
	GlobalTuneOptionsH2ZeroCopyFwdSendDisabled string = "disabled"
)
View Source 
const (

	// GlobalTuneOptionsIdlePoolSharedEnabled captures enum value "enabled"
	GlobalTuneOptionsIdlePoolSharedEnabled string = "enabled"

	// GlobalTuneOptionsIdlePoolSharedDisabled captures enum value "disabled"
	GlobalTuneOptionsIdlePoolSharedDisabled string = "disabled"
)
View Source 
const (

	// GlobalTuneOptionsListenerDefaultShardsByDashProcess captures enum value "by-process"
	GlobalTuneOptionsListenerDefaultShardsByDashProcess string = "by-process"

	// GlobalTuneOptionsListenerDefaultShardsByDashThread captures enum value "by-thread"
	GlobalTuneOptionsListenerDefaultShardsByDashThread string = "by-thread"

	// GlobalTuneOptionsListenerDefaultShardsByDashGroup captures enum value "by-group"
	GlobalTuneOptionsListenerDefaultShardsByDashGroup string = "by-group"
)
View Source 
const (

	// GlobalTuneOptionsListenerMultiQueueEnabled captures enum value "enabled"
	GlobalTuneOptionsListenerMultiQueueEnabled string = "enabled"

	// GlobalTuneOptionsListenerMultiQueueDisabled captures enum value "disabled"
	GlobalTuneOptionsListenerMultiQueueDisabled string = "disabled"
)
View Source 
const (

	// GlobalTuneOptionsLuaLogLoggersEnabled captures enum value "enabled"
	GlobalTuneOptionsLuaLogLoggersEnabled string = "enabled"

	// GlobalTuneOptionsLuaLogLoggersDisabled captures enum value "disabled"
	GlobalTuneOptionsLuaLogLoggersDisabled string = "disabled"
)
View Source 
const (

	// GlobalTuneOptionsLuaLogStderrAuto captures enum value "auto"
	GlobalTuneOptionsLuaLogStderrAuto string = "auto"

	// GlobalTuneOptionsLuaLogStderrEnabled captures enum value "enabled"
	GlobalTuneOptionsLuaLogStderrEnabled string = "enabled"

	// GlobalTuneOptionsLuaLogStderrDisabled captures enum value "disabled"
	GlobalTuneOptionsLuaLogStderrDisabled string = "disabled"
)
View Source 
const (

	// GlobalTuneOptionsPtZeroCopyForwardingEnabled captures enum value "enabled"
	GlobalTuneOptionsPtZeroCopyForwardingEnabled string = "enabled"

	// GlobalTuneOptionsPtZeroCopyForwardingDisabled captures enum value "disabled"
	GlobalTuneOptionsPtZeroCopyForwardingDisabled string = "disabled"
)
View Source 
const (

	// GlobalTuneOptionsQuicSocketOwnerListener captures enum value "listener"
	GlobalTuneOptionsQuicSocketOwnerListener string = "listener"

	// GlobalTuneOptionsQuicSocketOwnerConnection captures enum value "connection"
	GlobalTuneOptionsQuicSocketOwnerConnection string = "connection"
)
View Source 
const (

	// GlobalTuneOptionsSchedLowLatencyEnabled captures enum value "enabled"
	GlobalTuneOptionsSchedLowLatencyEnabled string = "enabled"

	// GlobalTuneOptionsSchedLowLatencyDisabled captures enum value "disabled"
	GlobalTuneOptionsSchedLowLatencyDisabled string = "disabled"
)
View Source 
const (

	// GlobalTuneOptionsSslKeylogEnabled captures enum value "enabled"
	GlobalTuneOptionsSslKeylogEnabled string = "enabled"

	// GlobalTuneOptionsSslKeylogDisabled captures enum value "disabled"
	GlobalTuneOptionsSslKeylogDisabled string = "disabled"
)
View Source 
const (

	// HashTypeFunctionSdbm captures enum value "sdbm"
	HashTypeFunctionSdbm string = "sdbm"

	// HashTypeFunctionDjb2 captures enum value "djb2"
	HashTypeFunctionDjb2 string = "djb2"

	// HashTypeFunctionWt6 captures enum value "wt6"
	HashTypeFunctionWt6 string = "wt6"

	// HashTypeFunctionCrc32 captures enum value "crc32"
	HashTypeFunctionCrc32 string = "crc32"

	// HashTypeFunctionNone captures enum value "none"
	HashTypeFunctionNone string = "none"
)
View Source 
const (

	// HashTypeMethodMapDashBased captures enum value "map-based"
	HashTypeMethodMapDashBased string = "map-based"

	// HashTypeMethodConsistent captures enum value "consistent"
	HashTypeMethodConsistent string = "consistent"
)
View Source 
const (

	// HealthHaproxyUp captures enum value "up"
	HealthHaproxyUp string = "up"

	// HealthHaproxyDown captures enum value "down"
	HealthHaproxyDown string = "down"

	// HealthHaproxyUnknown captures enum value "unknown"
	HealthHaproxyUnknown string = "unknown"
)
View Source 
const (

	// HTTPAfterResponseRuleCondIf captures enum value "if"
	HTTPAfterResponseRuleCondIf string = "if"

	// HTTPAfterResponseRuleCondUnless captures enum value "unless"
	HTTPAfterResponseRuleCondUnless string = "unless"
)
View Source 
const (

	// HTTPAfterResponseRuleLogLevelEmerg captures enum value "emerg"
	HTTPAfterResponseRuleLogLevelEmerg string = "emerg"

	// HTTPAfterResponseRuleLogLevelAlert captures enum value "alert"
	HTTPAfterResponseRuleLogLevelAlert string = "alert"

	// HTTPAfterResponseRuleLogLevelCrit captures enum value "crit"
	HTTPAfterResponseRuleLogLevelCrit string = "crit"

	// HTTPAfterResponseRuleLogLevelErr captures enum value "err"
	HTTPAfterResponseRuleLogLevelErr string = "err"

	// HTTPAfterResponseRuleLogLevelWarning captures enum value "warning"
	HTTPAfterResponseRuleLogLevelWarning string = "warning"

	// HTTPAfterResponseRuleLogLevelNotice captures enum value "notice"
	HTTPAfterResponseRuleLogLevelNotice string = "notice"

	// HTTPAfterResponseRuleLogLevelInfo captures enum value "info"
	HTTPAfterResponseRuleLogLevelInfo string = "info"

	// HTTPAfterResponseRuleLogLevelDebug captures enum value "debug"
	HTTPAfterResponseRuleLogLevelDebug string = "debug"

	// HTTPAfterResponseRuleLogLevelSilent captures enum value "silent"
	HTTPAfterResponseRuleLogLevelSilent string = "silent"
)
View Source 
const (

	// HTTPAfterResponseRuleStrictModeOn captures enum value "on"
	HTTPAfterResponseRuleStrictModeOn string = "on"

	// HTTPAfterResponseRuleStrictModeOff captures enum value "off"
	HTTPAfterResponseRuleStrictModeOff string = "off"
)
View Source 
const (

	// HTTPAfterResponseRuleTypeAddDashHeader captures enum value "add-header"
	HTTPAfterResponseRuleTypeAddDashHeader string = "add-header"

	// HTTPAfterResponseRuleTypeAllow captures enum value "allow"
	HTTPAfterResponseRuleTypeAllow string = "allow"

	// HTTPAfterResponseRuleTypeCapture captures enum value "capture"
	HTTPAfterResponseRuleTypeCapture string = "capture"

	// HTTPAfterResponseRuleTypeDelDashACL captures enum value "del-acl"
	HTTPAfterResponseRuleTypeDelDashACL string = "del-acl"

	// HTTPAfterResponseRuleTypeDelDashHeader captures enum value "del-header"
	HTTPAfterResponseRuleTypeDelDashHeader string = "del-header"

	// HTTPAfterResponseRuleTypeDelDashMap captures enum value "del-map"
	HTTPAfterResponseRuleTypeDelDashMap string = "del-map"

	// HTTPAfterResponseRuleTypeReplaceDashHeader captures enum value "replace-header"
	HTTPAfterResponseRuleTypeReplaceDashHeader string = "replace-header"

	// HTTPAfterResponseRuleTypeReplaceDashValue captures enum value "replace-value"
	HTTPAfterResponseRuleTypeReplaceDashValue string = "replace-value"

	// HTTPAfterResponseRuleTypeScDashAddDashGpc captures enum value "sc-add-gpc"
	HTTPAfterResponseRuleTypeScDashAddDashGpc string = "sc-add-gpc"

	// HTTPAfterResponseRuleTypeScDashIncDashGpc captures enum value "sc-inc-gpc"
	HTTPAfterResponseRuleTypeScDashIncDashGpc string = "sc-inc-gpc"

	// HTTPAfterResponseRuleTypeScDashIncDashGpc0 captures enum value "sc-inc-gpc0"
	HTTPAfterResponseRuleTypeScDashIncDashGpc0 string = "sc-inc-gpc0"

	// HTTPAfterResponseRuleTypeScDashIncDashGpc1 captures enum value "sc-inc-gpc1"
	HTTPAfterResponseRuleTypeScDashIncDashGpc1 string = "sc-inc-gpc1"

	// HTTPAfterResponseRuleTypeScDashSetDashGpt captures enum value "sc-set-gpt"
	HTTPAfterResponseRuleTypeScDashSetDashGpt string = "sc-set-gpt"

	// HTTPAfterResponseRuleTypeScDashSetDashGpt0 captures enum value "sc-set-gpt0"
	HTTPAfterResponseRuleTypeScDashSetDashGpt0 string = "sc-set-gpt0"

	// HTTPAfterResponseRuleTypeSetDashHeader captures enum value "set-header"
	HTTPAfterResponseRuleTypeSetDashHeader string = "set-header"

	// HTTPAfterResponseRuleTypeSetDashLogDashLevel captures enum value "set-log-level"
	HTTPAfterResponseRuleTypeSetDashLogDashLevel string = "set-log-level"

	// HTTPAfterResponseRuleTypeSetDashMap captures enum value "set-map"
	HTTPAfterResponseRuleTypeSetDashMap string = "set-map"

	// HTTPAfterResponseRuleTypeSetDashStatus captures enum value "set-status"
	HTTPAfterResponseRuleTypeSetDashStatus string = "set-status"

	// HTTPAfterResponseRuleTypeSetDashVar captures enum value "set-var"
	HTTPAfterResponseRuleTypeSetDashVar string = "set-var"

	// HTTPAfterResponseRuleTypeSetDashVarDashFmt captures enum value "set-var-fmt"
	HTTPAfterResponseRuleTypeSetDashVarDashFmt string = "set-var-fmt"

	// HTTPAfterResponseRuleTypeStrictDashMode captures enum value "strict-mode"
	HTTPAfterResponseRuleTypeStrictDashMode string = "strict-mode"

	// HTTPAfterResponseRuleTypeUnsetDashVar captures enum value "unset-var"
	HTTPAfterResponseRuleTypeUnsetDashVar string = "unset-var"
)
View Source 
const (

	// HTTPCheckErrorStatusL7OKC captures enum value "L7OKC"
	HTTPCheckErrorStatusL7OKC string = "L7OKC"

	// HTTPCheckErrorStatusL7RSP captures enum value "L7RSP"
	HTTPCheckErrorStatusL7RSP string = "L7RSP"

	// HTTPCheckErrorStatusL7STS captures enum value "L7STS"
	HTTPCheckErrorStatusL7STS string = "L7STS"

	// HTTPCheckErrorStatusL6RSP captures enum value "L6RSP"
	HTTPCheckErrorStatusL6RSP string = "L6RSP"

	// HTTPCheckErrorStatusL4CON captures enum value "L4CON"
	HTTPCheckErrorStatusL4CON string = "L4CON"
)
View Source 
const (

	// HTTPCheckMatchStatus captures enum value "status"
	HTTPCheckMatchStatus string = "status"

	// HTTPCheckMatchRstatus captures enum value "rstatus"
	HTTPCheckMatchRstatus string = "rstatus"

	// HTTPCheckMatchHdr captures enum value "hdr"
	HTTPCheckMatchHdr string = "hdr"

	// HTTPCheckMatchFhdr captures enum value "fhdr"
	HTTPCheckMatchFhdr string = "fhdr"

	// HTTPCheckMatchString captures enum value "string"
	HTTPCheckMatchString string = "string"

	// HTTPCheckMatchRstring captures enum value "rstring"
	HTTPCheckMatchRstring string = "rstring"
)
View Source 
const (

	// HTTPCheckMethodHEAD captures enum value "HEAD"
	HTTPCheckMethodHEAD string = "HEAD"

	// HTTPCheckMethodPUT captures enum value "PUT"
	HTTPCheckMethodPUT string = "PUT"

	// HTTPCheckMethodPOST captures enum value "POST"
	HTTPCheckMethodPOST string = "POST"

	// HTTPCheckMethodGET captures enum value "GET"
	HTTPCheckMethodGET string = "GET"

	// HTTPCheckMethodTRACE captures enum value "TRACE"
	HTTPCheckMethodTRACE string = "TRACE"

	// HTTPCheckMethodPATCH captures enum value "PATCH"
	HTTPCheckMethodPATCH string = "PATCH"

	// HTTPCheckMethodDELETE captures enum value "DELETE"
	HTTPCheckMethodDELETE string = "DELETE"

	// HTTPCheckMethodCONNECT captures enum value "CONNECT"
	HTTPCheckMethodCONNECT string = "CONNECT"

	// HTTPCheckMethodOPTIONS captures enum value "OPTIONS"
	HTTPCheckMethodOPTIONS string = "OPTIONS"
)
View Source 
const (

	// HTTPCheckOkStatusL7OK captures enum value "L7OK"
	HTTPCheckOkStatusL7OK string = "L7OK"

	// HTTPCheckOkStatusL7OKC captures enum value "L7OKC"
	HTTPCheckOkStatusL7OKC string = "L7OKC"

	// HTTPCheckOkStatusL6OK captures enum value "L6OK"
	HTTPCheckOkStatusL6OK string = "L6OK"

	// HTTPCheckOkStatusL4OK captures enum value "L4OK"
	HTTPCheckOkStatusL4OK string = "L4OK"
)
View Source 
const (

	// HTTPCheckToutStatusL7TOUT captures enum value "L7TOUT"
	HTTPCheckToutStatusL7TOUT string = "L7TOUT"

	// HTTPCheckToutStatusL6TOUT captures enum value "L6TOUT"
	HTTPCheckToutStatusL6TOUT string = "L6TOUT"

	// HTTPCheckToutStatusL4TOUT captures enum value "L4TOUT"
	HTTPCheckToutStatusL4TOUT string = "L4TOUT"
)
View Source 
const (

	// HTTPCheckTypeComment captures enum value "comment"
	HTTPCheckTypeComment string = "comment"

	// HTTPCheckTypeConnect captures enum value "connect"
	HTTPCheckTypeConnect string = "connect"

	// HTTPCheckTypeDisableDashOnDash404 captures enum value "disable-on-404"
	HTTPCheckTypeDisableDashOnDash404 string = "disable-on-404"

	// HTTPCheckTypeExpect captures enum value "expect"
	HTTPCheckTypeExpect string = "expect"

	// HTTPCheckTypeSend captures enum value "send"
	HTTPCheckTypeSend string = "send"

	// HTTPCheckTypeSendDashState captures enum value "send-state"
	HTTPCheckTypeSendDashState string = "send-state"

	// HTTPCheckTypeSetDashVar captures enum value "set-var"
	HTTPCheckTypeSetDashVar string = "set-var"

	// HTTPCheckTypeSetDashVarDashFmt captures enum value "set-var-fmt"
	HTTPCheckTypeSetDashVarDashFmt string = "set-var-fmt"

	// HTTPCheckTypeUnsetDashVar captures enum value "unset-var"
	HTTPCheckTypeUnsetDashVar string = "unset-var"
)
View Source 
const (

	// HTTPErrorRuleReturnContentFormatDefaultDashErrorfiles captures enum value "default-errorfiles"
	HTTPErrorRuleReturnContentFormatDefaultDashErrorfiles string = "default-errorfiles"

	// HTTPErrorRuleReturnContentFormatErrorfile captures enum value "errorfile"
	HTTPErrorRuleReturnContentFormatErrorfile string = "errorfile"

	// HTTPErrorRuleReturnContentFormatErrorfiles captures enum value "errorfiles"
	HTTPErrorRuleReturnContentFormatErrorfiles string = "errorfiles"

	// HTTPErrorRuleReturnContentFormatFile captures enum value "file"
	HTTPErrorRuleReturnContentFormatFile string = "file"

	// HTTPErrorRuleReturnContentFormatLfDashFile captures enum value "lf-file"
	HTTPErrorRuleReturnContentFormatLfDashFile string = "lf-file"

	// HTTPErrorRuleReturnContentFormatString captures enum value "string"
	HTTPErrorRuleReturnContentFormatString string = "string"

	// HTTPErrorRuleReturnContentFormatLfDashString captures enum value "lf-string"
	HTTPErrorRuleReturnContentFormatLfDashString string = "lf-string"
)
View Source 
const (

	// HTTPRequestRuleCondIf captures enum value "if"
	HTTPRequestRuleCondIf string = "if"

	// HTTPRequestRuleCondUnless captures enum value "unless"
	HTTPRequestRuleCondUnless string = "unless"
)
View Source 
const (

	// HTTPRequestRuleLogLevelEmerg captures enum value "emerg"
	HTTPRequestRuleLogLevelEmerg string = "emerg"

	// HTTPRequestRuleLogLevelAlert captures enum value "alert"
	HTTPRequestRuleLogLevelAlert string = "alert"

	// HTTPRequestRuleLogLevelCrit captures enum value "crit"
	HTTPRequestRuleLogLevelCrit string = "crit"

	// HTTPRequestRuleLogLevelErr captures enum value "err"
	HTTPRequestRuleLogLevelErr string = "err"

	// HTTPRequestRuleLogLevelWarning captures enum value "warning"
	HTTPRequestRuleLogLevelWarning string = "warning"

	// HTTPRequestRuleLogLevelNotice captures enum value "notice"
	HTTPRequestRuleLogLevelNotice string = "notice"

	// HTTPRequestRuleLogLevelInfo captures enum value "info"
	HTTPRequestRuleLogLevelInfo string = "info"

	// HTTPRequestRuleLogLevelDebug captures enum value "debug"
	HTTPRequestRuleLogLevelDebug string = "debug"

	// HTTPRequestRuleLogLevelSilent captures enum value "silent"
	HTTPRequestRuleLogLevelSilent string = "silent"
)
View Source 
const (

	// HTTPRequestRuleNormalizerFragmentDashEncode captures enum value "fragment-encode"
	HTTPRequestRuleNormalizerFragmentDashEncode string = "fragment-encode"

	// HTTPRequestRuleNormalizerFragmentDashStrip captures enum value "fragment-strip"
	HTTPRequestRuleNormalizerFragmentDashStrip string = "fragment-strip"

	// HTTPRequestRuleNormalizerPathDashMergeDashSlashes captures enum value "path-merge-slashes"
	HTTPRequestRuleNormalizerPathDashMergeDashSlashes string = "path-merge-slashes"

	// HTTPRequestRuleNormalizerPathDashStripDashDot captures enum value "path-strip-dot"
	HTTPRequestRuleNormalizerPathDashStripDashDot string = "path-strip-dot"

	// HTTPRequestRuleNormalizerPathDashStripDashDotdot captures enum value "path-strip-dotdot"
	HTTPRequestRuleNormalizerPathDashStripDashDotdot string = "path-strip-dotdot"

	// HTTPRequestRuleNormalizerPercentDashDecodeDashUnreserved captures enum value "percent-decode-unreserved"
	HTTPRequestRuleNormalizerPercentDashDecodeDashUnreserved string = "percent-decode-unreserved"

	// HTTPRequestRuleNormalizerPercentDashToDashUppercase captures enum value "percent-to-uppercase"
	HTTPRequestRuleNormalizerPercentDashToDashUppercase string = "percent-to-uppercase"

	// HTTPRequestRuleNormalizerQueryDashSortDashByDashName captures enum value "query-sort-by-name"
	HTTPRequestRuleNormalizerQueryDashSortDashByDashName string = "query-sort-by-name"
)
View Source 
const (

	// HTTPRequestRuleProtocolIPV4 captures enum value "ipv4"
	HTTPRequestRuleProtocolIPV4 string = "ipv4"

	// HTTPRequestRuleProtocolIPV6 captures enum value "ipv6"
	HTTPRequestRuleProtocolIPV6 string = "ipv6"
)
View Source 
const (

	// HTTPRequestRuleRedirTypeLocation captures enum value "location"
	HTTPRequestRuleRedirTypeLocation string = "location"

	// HTTPRequestRuleRedirTypePrefix captures enum value "prefix"
	HTTPRequestRuleRedirTypePrefix string = "prefix"

	// HTTPRequestRuleRedirTypeScheme captures enum value "scheme"
	HTTPRequestRuleRedirTypeScheme string = "scheme"
)
View Source 
const (

	// HTTPRequestRuleReturnContentFormatDefaultDashErrorfiles captures enum value "default-errorfiles"
	HTTPRequestRuleReturnContentFormatDefaultDashErrorfiles string = "default-errorfiles"

	// HTTPRequestRuleReturnContentFormatErrorfile captures enum value "errorfile"
	HTTPRequestRuleReturnContentFormatErrorfile string = "errorfile"

	// HTTPRequestRuleReturnContentFormatErrorfiles captures enum value "errorfiles"
	HTTPRequestRuleReturnContentFormatErrorfiles string = "errorfiles"

	// HTTPRequestRuleReturnContentFormatFile captures enum value "file"
	HTTPRequestRuleReturnContentFormatFile string = "file"

	// HTTPRequestRuleReturnContentFormatLfDashFile captures enum value "lf-file"
	HTTPRequestRuleReturnContentFormatLfDashFile string = "lf-file"

	// HTTPRequestRuleReturnContentFormatString captures enum value "string"
	HTTPRequestRuleReturnContentFormatString string = "string"

	// HTTPRequestRuleReturnContentFormatLfDashString captures enum value "lf-string"
	HTTPRequestRuleReturnContentFormatLfDashString string = "lf-string"
)
View Source 
const (

	// HTTPRequestRuleStrictModeOn captures enum value "on"
	HTTPRequestRuleStrictModeOn string = "on"

	// HTTPRequestRuleStrictModeOff captures enum value "off"
	HTTPRequestRuleStrictModeOff string = "off"
)
View Source 
const (

	// HTTPRequestRuleTimeoutTypeServer captures enum value "server"
	HTTPRequestRuleTimeoutTypeServer string = "server"

	// HTTPRequestRuleTimeoutTypeTunnel captures enum value "tunnel"
	HTTPRequestRuleTimeoutTypeTunnel string = "tunnel"

	// HTTPRequestRuleTimeoutTypeClient captures enum value "client"
	HTTPRequestRuleTimeoutTypeClient string = "client"
)
View Source 
const (

	// HTTPRequestRuleTypeAddDashACL captures enum value "add-acl"
	HTTPRequestRuleTypeAddDashACL string = "add-acl"

	// HTTPRequestRuleTypeAddDashHeader captures enum value "add-header"
	HTTPRequestRuleTypeAddDashHeader string = "add-header"

	// HTTPRequestRuleTypeAllow captures enum value "allow"
	HTTPRequestRuleTypeAllow string = "allow"

	// HTTPRequestRuleTypeAuth captures enum value "auth"
	HTTPRequestRuleTypeAuth string = "auth"

	// HTTPRequestRuleTypeCacheDashUse captures enum value "cache-use"
	HTTPRequestRuleTypeCacheDashUse string = "cache-use"

	// HTTPRequestRuleTypeCapture captures enum value "capture"
	HTTPRequestRuleTypeCapture string = "capture"

	// HTTPRequestRuleTypeDelDashACL captures enum value "del-acl"
	HTTPRequestRuleTypeDelDashACL string = "del-acl"

	// HTTPRequestRuleTypeDelDashHeader captures enum value "del-header"
	HTTPRequestRuleTypeDelDashHeader string = "del-header"

	// HTTPRequestRuleTypeDelDashMap captures enum value "del-map"
	HTTPRequestRuleTypeDelDashMap string = "del-map"

	// HTTPRequestRuleTypeDeny captures enum value "deny"
	HTTPRequestRuleTypeDeny string = "deny"

	// HTTPRequestRuleTypeDisableDashL7DashRetry captures enum value "disable-l7-retry"
	HTTPRequestRuleTypeDisableDashL7DashRetry string = "disable-l7-retry"

	// HTTPRequestRuleTypeDoDashResolve captures enum value "do-resolve"
	HTTPRequestRuleTypeDoDashResolve string = "do-resolve"

	// HTTPRequestRuleTypeEarlyDashHint captures enum value "early-hint"
	HTTPRequestRuleTypeEarlyDashHint string = "early-hint"

	// HTTPRequestRuleTypeLua captures enum value "lua"
	HTTPRequestRuleTypeLua string = "lua"

	// HTTPRequestRuleTypeNormalizeDashURI captures enum value "normalize-uri"
	HTTPRequestRuleTypeNormalizeDashURI string = "normalize-uri"

	// HTTPRequestRuleTypeRedirect captures enum value "redirect"
	HTTPRequestRuleTypeRedirect string = "redirect"

	// HTTPRequestRuleTypeReject captures enum value "reject"
	HTTPRequestRuleTypeReject string = "reject"

	// HTTPRequestRuleTypeReplaceDashHeader captures enum value "replace-header"
	HTTPRequestRuleTypeReplaceDashHeader string = "replace-header"

	// HTTPRequestRuleTypeReplaceDashPath captures enum value "replace-path"
	HTTPRequestRuleTypeReplaceDashPath string = "replace-path"

	// HTTPRequestRuleTypeReplaceDashPathq captures enum value "replace-pathq"
	HTTPRequestRuleTypeReplaceDashPathq string = "replace-pathq"

	// HTTPRequestRuleTypeReplaceDashURI captures enum value "replace-uri"
	HTTPRequestRuleTypeReplaceDashURI string = "replace-uri"

	// HTTPRequestRuleTypeReplaceDashValue captures enum value "replace-value"
	HTTPRequestRuleTypeReplaceDashValue string = "replace-value"

	// HTTPRequestRuleTypeReturn captures enum value "return"
	HTTPRequestRuleTypeReturn string = "return"

	// HTTPRequestRuleTypeScDashAddDashGpc captures enum value "sc-add-gpc"
	HTTPRequestRuleTypeScDashAddDashGpc string = "sc-add-gpc"

	// HTTPRequestRuleTypeScDashIncDashGpc captures enum value "sc-inc-gpc"
	HTTPRequestRuleTypeScDashIncDashGpc string = "sc-inc-gpc"

	// HTTPRequestRuleTypeScDashIncDashGpc0 captures enum value "sc-inc-gpc0"
	HTTPRequestRuleTypeScDashIncDashGpc0 string = "sc-inc-gpc0"

	// HTTPRequestRuleTypeScDashIncDashGpc1 captures enum value "sc-inc-gpc1"
	HTTPRequestRuleTypeScDashIncDashGpc1 string = "sc-inc-gpc1"

	// HTTPRequestRuleTypeScDashSetDashGpt captures enum value "sc-set-gpt"
	HTTPRequestRuleTypeScDashSetDashGpt string = "sc-set-gpt"

	// HTTPRequestRuleTypeScDashSetDashGpt0 captures enum value "sc-set-gpt0"
	HTTPRequestRuleTypeScDashSetDashGpt0 string = "sc-set-gpt0"

	// HTTPRequestRuleTypeSendDashSpoeDashGroup captures enum value "send-spoe-group"
	HTTPRequestRuleTypeSendDashSpoeDashGroup string = "send-spoe-group"

	// HTTPRequestRuleTypeSetDashDst captures enum value "set-dst"
	HTTPRequestRuleTypeSetDashDst string = "set-dst"

	// HTTPRequestRuleTypeSetDashDstDashPort captures enum value "set-dst-port"
	HTTPRequestRuleTypeSetDashDstDashPort string = "set-dst-port"

	// HTTPRequestRuleTypeSetDashHeader captures enum value "set-header"
	HTTPRequestRuleTypeSetDashHeader string = "set-header"

	// HTTPRequestRuleTypeSetDashLogDashLevel captures enum value "set-log-level"
	HTTPRequestRuleTypeSetDashLogDashLevel string = "set-log-level"

	// HTTPRequestRuleTypeSetDashMap captures enum value "set-map"
	HTTPRequestRuleTypeSetDashMap string = "set-map"

	// HTTPRequestRuleTypeSetDashMark captures enum value "set-mark"
	HTTPRequestRuleTypeSetDashMark string = "set-mark"

	// HTTPRequestRuleTypeSetDashMethod captures enum value "set-method"
	HTTPRequestRuleTypeSetDashMethod string = "set-method"

	// HTTPRequestRuleTypeSetDashNice captures enum value "set-nice"
	HTTPRequestRuleTypeSetDashNice string = "set-nice"

	// HTTPRequestRuleTypeSetDashPath captures enum value "set-path"
	HTTPRequestRuleTypeSetDashPath string = "set-path"

	// HTTPRequestRuleTypeSetDashPathq captures enum value "set-pathq"
	HTTPRequestRuleTypeSetDashPathq string = "set-pathq"

	// HTTPRequestRuleTypeSetDashPriorityDashClass captures enum value "set-priority-class"
	HTTPRequestRuleTypeSetDashPriorityDashClass string = "set-priority-class"

	// HTTPRequestRuleTypeSetDashPriorityDashOffset captures enum value "set-priority-offset"
	HTTPRequestRuleTypeSetDashPriorityDashOffset string = "set-priority-offset"

	// HTTPRequestRuleTypeSetDashQuery captures enum value "set-query"
	HTTPRequestRuleTypeSetDashQuery string = "set-query"

	// HTTPRequestRuleTypeSetDashSrc captures enum value "set-src"
	HTTPRequestRuleTypeSetDashSrc string = "set-src"

	// HTTPRequestRuleTypeSetDashSrcDashPort captures enum value "set-src-port"
	HTTPRequestRuleTypeSetDashSrcDashPort string = "set-src-port"

	// HTTPRequestRuleTypeSetDashTimeout captures enum value "set-timeout"
	HTTPRequestRuleTypeSetDashTimeout string = "set-timeout"

	// HTTPRequestRuleTypeSetDashTos captures enum value "set-tos"
	HTTPRequestRuleTypeSetDashTos string = "set-tos"

	// HTTPRequestRuleTypeSetDashURI captures enum value "set-uri"
	HTTPRequestRuleTypeSetDashURI string = "set-uri"

	// HTTPRequestRuleTypeSetDashVar captures enum value "set-var"
	HTTPRequestRuleTypeSetDashVar string = "set-var"

	// HTTPRequestRuleTypeSilentDashDrop captures enum value "silent-drop"
	HTTPRequestRuleTypeSilentDashDrop string = "silent-drop"

	// HTTPRequestRuleTypeStrictDashMode captures enum value "strict-mode"
	HTTPRequestRuleTypeStrictDashMode string = "strict-mode"

	// HTTPRequestRuleTypeTarpit captures enum value "tarpit"
	HTTPRequestRuleTypeTarpit string = "tarpit"

	// HTTPRequestRuleTypeTrackDashSc0 captures enum value "track-sc0"
	HTTPRequestRuleTypeTrackDashSc0 string = "track-sc0"

	// HTTPRequestRuleTypeTrackDashSc1 captures enum value "track-sc1"
	HTTPRequestRuleTypeTrackDashSc1 string = "track-sc1"

	// HTTPRequestRuleTypeTrackDashSc2 captures enum value "track-sc2"
	HTTPRequestRuleTypeTrackDashSc2 string = "track-sc2"

	// HTTPRequestRuleTypeTrackDashSc captures enum value "track-sc"
	HTTPRequestRuleTypeTrackDashSc string = "track-sc"

	// HTTPRequestRuleTypeUnsetDashVar captures enum value "unset-var"
	HTTPRequestRuleTypeUnsetDashVar string = "unset-var"

	// HTTPRequestRuleTypeUseDashService captures enum value "use-service"
	HTTPRequestRuleTypeUseDashService string = "use-service"

	// HTTPRequestRuleTypeWaitDashForDashBody captures enum value "wait-for-body"
	HTTPRequestRuleTypeWaitDashForDashBody string = "wait-for-body"

	// HTTPRequestRuleTypeWaitDashForDashHandshake captures enum value "wait-for-handshake"
	HTTPRequestRuleTypeWaitDashForDashHandshake string = "wait-for-handshake"

	// HTTPRequestRuleTypeSetDashBandwidthDashLimit captures enum value "set-bandwidth-limit"
	HTTPRequestRuleTypeSetDashBandwidthDashLimit string = "set-bandwidth-limit"
)
View Source 
const (

	// HTTPResponseRuleCondIf captures enum value "if"
	HTTPResponseRuleCondIf string = "if"

	// HTTPResponseRuleCondUnless captures enum value "unless"
	HTTPResponseRuleCondUnless string = "unless"
)
View Source 
const (

	// HTTPResponseRuleLogLevelEmerg captures enum value "emerg"
	HTTPResponseRuleLogLevelEmerg string = "emerg"

	// HTTPResponseRuleLogLevelAlert captures enum value "alert"
	HTTPResponseRuleLogLevelAlert string = "alert"

	// HTTPResponseRuleLogLevelCrit captures enum value "crit"
	HTTPResponseRuleLogLevelCrit string = "crit"

	// HTTPResponseRuleLogLevelErr captures enum value "err"
	HTTPResponseRuleLogLevelErr string = "err"

	// HTTPResponseRuleLogLevelWarning captures enum value "warning"
	HTTPResponseRuleLogLevelWarning string = "warning"

	// HTTPResponseRuleLogLevelNotice captures enum value "notice"
	HTTPResponseRuleLogLevelNotice string = "notice"

	// HTTPResponseRuleLogLevelInfo captures enum value "info"
	HTTPResponseRuleLogLevelInfo string = "info"

	// HTTPResponseRuleLogLevelDebug captures enum value "debug"
	HTTPResponseRuleLogLevelDebug string = "debug"

	// HTTPResponseRuleLogLevelSilent captures enum value "silent"
	HTTPResponseRuleLogLevelSilent string = "silent"
)
View Source 
const (

	// HTTPResponseRuleRedirTypeLocation captures enum value "location"
	HTTPResponseRuleRedirTypeLocation string = "location"

	// HTTPResponseRuleRedirTypePrefix captures enum value "prefix"
	HTTPResponseRuleRedirTypePrefix string = "prefix"

	// HTTPResponseRuleRedirTypeScheme captures enum value "scheme"
	HTTPResponseRuleRedirTypeScheme string = "scheme"
)
View Source 
const (

	// HTTPResponseRuleReturnContentFormatDefaultDashErrorfiles captures enum value "default-errorfiles"
	HTTPResponseRuleReturnContentFormatDefaultDashErrorfiles string = "default-errorfiles"

	// HTTPResponseRuleReturnContentFormatErrorfile captures enum value "errorfile"
	HTTPResponseRuleReturnContentFormatErrorfile string = "errorfile"

	// HTTPResponseRuleReturnContentFormatErrorfiles captures enum value "errorfiles"
	HTTPResponseRuleReturnContentFormatErrorfiles string = "errorfiles"

	// HTTPResponseRuleReturnContentFormatFile captures enum value "file"
	HTTPResponseRuleReturnContentFormatFile string = "file"

	// HTTPResponseRuleReturnContentFormatLfDashFile captures enum value "lf-file"
	HTTPResponseRuleReturnContentFormatLfDashFile string = "lf-file"

	// HTTPResponseRuleReturnContentFormatString captures enum value "string"
	HTTPResponseRuleReturnContentFormatString string = "string"

	// HTTPResponseRuleReturnContentFormatLfDashString captures enum value "lf-string"
	HTTPResponseRuleReturnContentFormatLfDashString string = "lf-string"
)
View Source 
const (

	// HTTPResponseRuleStrictModeOn captures enum value "on"
	HTTPResponseRuleStrictModeOn string = "on"

	// HTTPResponseRuleStrictModeOff captures enum value "off"
	HTTPResponseRuleStrictModeOff string = "off"
)
View Source 
const (

	// HTTPResponseRuleTimeoutTypeServer captures enum value "server"
	HTTPResponseRuleTimeoutTypeServer string = "server"

	// HTTPResponseRuleTimeoutTypeTunnel captures enum value "tunnel"
	HTTPResponseRuleTimeoutTypeTunnel string = "tunnel"

	// HTTPResponseRuleTimeoutTypeClient captures enum value "client"
	HTTPResponseRuleTimeoutTypeClient string = "client"
)
View Source 
const (

	// HTTPResponseRuleTypeAddDashACL captures enum value "add-acl"
	HTTPResponseRuleTypeAddDashACL string = "add-acl"

	// HTTPResponseRuleTypeAddDashHeader captures enum value "add-header"
	HTTPResponseRuleTypeAddDashHeader string = "add-header"

	// HTTPResponseRuleTypeAllow captures enum value "allow"
	HTTPResponseRuleTypeAllow string = "allow"

	// HTTPResponseRuleTypeCacheDashStore captures enum value "cache-store"
	HTTPResponseRuleTypeCacheDashStore string = "cache-store"

	// HTTPResponseRuleTypeCapture captures enum value "capture"
	HTTPResponseRuleTypeCapture string = "capture"

	// HTTPResponseRuleTypeDelDashACL captures enum value "del-acl"
	HTTPResponseRuleTypeDelDashACL string = "del-acl"

	// HTTPResponseRuleTypeDelDashHeader captures enum value "del-header"
	HTTPResponseRuleTypeDelDashHeader string = "del-header"

	// HTTPResponseRuleTypeDelDashMap captures enum value "del-map"
	HTTPResponseRuleTypeDelDashMap string = "del-map"

	// HTTPResponseRuleTypeDeny captures enum value "deny"
	HTTPResponseRuleTypeDeny string = "deny"

	// HTTPResponseRuleTypeLua captures enum value "lua"
	HTTPResponseRuleTypeLua string = "lua"

	// HTTPResponseRuleTypeRedirect captures enum value "redirect"
	HTTPResponseRuleTypeRedirect string = "redirect"

	// HTTPResponseRuleTypeReplaceDashHeader captures enum value "replace-header"
	HTTPResponseRuleTypeReplaceDashHeader string = "replace-header"

	// HTTPResponseRuleTypeReplaceDashValue captures enum value "replace-value"
	HTTPResponseRuleTypeReplaceDashValue string = "replace-value"

	// HTTPResponseRuleTypeReturn captures enum value "return"
	HTTPResponseRuleTypeReturn string = "return"

	// HTTPResponseRuleTypeScDashAddDashGpc captures enum value "sc-add-gpc"
	HTTPResponseRuleTypeScDashAddDashGpc string = "sc-add-gpc"

	// HTTPResponseRuleTypeScDashIncDashGpc captures enum value "sc-inc-gpc"
	HTTPResponseRuleTypeScDashIncDashGpc string = "sc-inc-gpc"

	// HTTPResponseRuleTypeScDashIncDashGpc0 captures enum value "sc-inc-gpc0"
	HTTPResponseRuleTypeScDashIncDashGpc0 string = "sc-inc-gpc0"

	// HTTPResponseRuleTypeScDashIncDashGpc1 captures enum value "sc-inc-gpc1"
	HTTPResponseRuleTypeScDashIncDashGpc1 string = "sc-inc-gpc1"

	// HTTPResponseRuleTypeScDashSetDashGpt captures enum value "sc-set-gpt"
	HTTPResponseRuleTypeScDashSetDashGpt string = "sc-set-gpt"

	// HTTPResponseRuleTypeScDashSetDashGpt0 captures enum value "sc-set-gpt0"
	HTTPResponseRuleTypeScDashSetDashGpt0 string = "sc-set-gpt0"

	// HTTPResponseRuleTypeSendDashSpoeDashGroup captures enum value "send-spoe-group"
	HTTPResponseRuleTypeSendDashSpoeDashGroup string = "send-spoe-group"

	// HTTPResponseRuleTypeSetDashHeader captures enum value "set-header"
	HTTPResponseRuleTypeSetDashHeader string = "set-header"

	// HTTPResponseRuleTypeSetDashLogDashLevel captures enum value "set-log-level"
	HTTPResponseRuleTypeSetDashLogDashLevel string = "set-log-level"

	// HTTPResponseRuleTypeSetDashMap captures enum value "set-map"
	HTTPResponseRuleTypeSetDashMap string = "set-map"

	// HTTPResponseRuleTypeSetDashMark captures enum value "set-mark"
	HTTPResponseRuleTypeSetDashMark string = "set-mark"

	// HTTPResponseRuleTypeSetDashNice captures enum value "set-nice"
	HTTPResponseRuleTypeSetDashNice string = "set-nice"

	// HTTPResponseRuleTypeSetDashStatus captures enum value "set-status"
	HTTPResponseRuleTypeSetDashStatus string = "set-status"

	// HTTPResponseRuleTypeSetDashTimeout captures enum value "set-timeout"
	HTTPResponseRuleTypeSetDashTimeout string = "set-timeout"

	// HTTPResponseRuleTypeSetDashTos captures enum value "set-tos"
	HTTPResponseRuleTypeSetDashTos string = "set-tos"

	// HTTPResponseRuleTypeSetDashVar captures enum value "set-var"
	HTTPResponseRuleTypeSetDashVar string = "set-var"

	// HTTPResponseRuleTypeSetDashVarDashFmt captures enum value "set-var-fmt"
	HTTPResponseRuleTypeSetDashVarDashFmt string = "set-var-fmt"

	// HTTPResponseRuleTypeSilentDashDrop captures enum value "silent-drop"
	HTTPResponseRuleTypeSilentDashDrop string = "silent-drop"

	// HTTPResponseRuleTypeStrictDashMode captures enum value "strict-mode"
	HTTPResponseRuleTypeStrictDashMode string = "strict-mode"

	// HTTPResponseRuleTypeTrackDashSc0 captures enum value "track-sc0"
	HTTPResponseRuleTypeTrackDashSc0 string = "track-sc0"

	// HTTPResponseRuleTypeTrackDashSc1 captures enum value "track-sc1"
	HTTPResponseRuleTypeTrackDashSc1 string = "track-sc1"

	// HTTPResponseRuleTypeTrackDashSc2 captures enum value "track-sc2"
	HTTPResponseRuleTypeTrackDashSc2 string = "track-sc2"

	// HTTPResponseRuleTypeTrackDashSc captures enum value "track-sc"
	HTTPResponseRuleTypeTrackDashSc string = "track-sc"

	// HTTPResponseRuleTypeUnsetDashVar captures enum value "unset-var"
	HTTPResponseRuleTypeUnsetDashVar string = "unset-var"

	// HTTPResponseRuleTypeWaitDashForDashBody captures enum value "wait-for-body"
	HTTPResponseRuleTypeWaitDashForDashBody string = "wait-for-body"

	// HTTPResponseRuleTypeSetDashBandwidthDashLimit captures enum value "set-bandwidth-limit"
	HTTPResponseRuleTypeSetDashBandwidthDashLimit string = "set-bandwidth-limit"
)
View Source 
const (

	// HttpchkParamsMethodHEAD captures enum value "HEAD"
	HttpchkParamsMethodHEAD string = "HEAD"

	// HttpchkParamsMethodPUT captures enum value "PUT"
	HttpchkParamsMethodPUT string = "PUT"

	// HttpchkParamsMethodPOST captures enum value "POST"
	HttpchkParamsMethodPOST string = "POST"

	// HttpchkParamsMethodGET captures enum value "GET"
	HttpchkParamsMethodGET string = "GET"

	// HttpchkParamsMethodTRACE captures enum value "TRACE"
	HttpchkParamsMethodTRACE string = "TRACE"

	// HttpchkParamsMethodPATCH captures enum value "PATCH"
	HttpchkParamsMethodPATCH string = "PATCH"

	// HttpchkParamsMethodDELETE captures enum value "DELETE"
	HttpchkParamsMethodDELETE string = "DELETE"

	// HttpchkParamsMethodCONNECT captures enum value "CONNECT"
	HttpchkParamsMethodCONNECT string = "CONNECT"

	// HttpchkParamsMethodOPTIONS captures enum value "OPTIONS"
	HttpchkParamsMethodOPTIONS string = "OPTIONS"
)
View Source 
const (

	// LogTargetFacilityKern captures enum value "kern"
	LogTargetFacilityKern string = "kern"

	// LogTargetFacilityUser captures enum value "user"
	LogTargetFacilityUser string = "user"

	// LogTargetFacilityMail captures enum value "mail"
	LogTargetFacilityMail string = "mail"

	// LogTargetFacilityDaemon captures enum value "daemon"
	LogTargetFacilityDaemon string = "daemon"

	// LogTargetFacilityAuth captures enum value "auth"
	LogTargetFacilityAuth string = "auth"

	// LogTargetFacilitySyslog captures enum value "syslog"
	LogTargetFacilitySyslog string = "syslog"

	// LogTargetFacilityLpr captures enum value "lpr"
	LogTargetFacilityLpr string = "lpr"

	// LogTargetFacilityNews captures enum value "news"
	LogTargetFacilityNews string = "news"

	// LogTargetFacilityUucp captures enum value "uucp"
	LogTargetFacilityUucp string = "uucp"

	// LogTargetFacilityCron captures enum value "cron"
	LogTargetFacilityCron string = "cron"

	// LogTargetFacilityAuth2 captures enum value "auth2"
	LogTargetFacilityAuth2 string = "auth2"

	// LogTargetFacilityFtp captures enum value "ftp"
	LogTargetFacilityFtp string = "ftp"

	// LogTargetFacilityNtp captures enum value "ntp"
	LogTargetFacilityNtp string = "ntp"

	// LogTargetFacilityAudit captures enum value "audit"
	LogTargetFacilityAudit string = "audit"

	// LogTargetFacilityAlert captures enum value "alert"
	LogTargetFacilityAlert string = "alert"

	// LogTargetFacilityCron2 captures enum value "cron2"
	LogTargetFacilityCron2 string = "cron2"

	// LogTargetFacilityLocal0 captures enum value "local0"
	LogTargetFacilityLocal0 string = "local0"

	// LogTargetFacilityLocal1 captures enum value "local1"
	LogTargetFacilityLocal1 string = "local1"

	// LogTargetFacilityLocal2 captures enum value "local2"
	LogTargetFacilityLocal2 string = "local2"

	// LogTargetFacilityLocal3 captures enum value "local3"
	LogTargetFacilityLocal3 string = "local3"

	// LogTargetFacilityLocal4 captures enum value "local4"
	LogTargetFacilityLocal4 string = "local4"

	// LogTargetFacilityLocal5 captures enum value "local5"
	LogTargetFacilityLocal5 string = "local5"

	// LogTargetFacilityLocal6 captures enum value "local6"
	LogTargetFacilityLocal6 string = "local6"

	// LogTargetFacilityLocal7 captures enum value "local7"
	LogTargetFacilityLocal7 string = "local7"
)
View Source 
const (

	// LogTargetFormatLocal captures enum value "local"
	LogTargetFormatLocal string = "local"

	// LogTargetFormatRfc3164 captures enum value "rfc3164"
	LogTargetFormatRfc3164 string = "rfc3164"

	// LogTargetFormatRfc5424 captures enum value "rfc5424"
	LogTargetFormatRfc5424 string = "rfc5424"

	// LogTargetFormatPriority captures enum value "priority"
	LogTargetFormatPriority string = "priority"

	// LogTargetFormatShort captures enum value "short"
	LogTargetFormatShort string = "short"

	// LogTargetFormatTimed captures enum value "timed"
	LogTargetFormatTimed string = "timed"

	// LogTargetFormatIso captures enum value "iso"
	LogTargetFormatIso string = "iso"

	// LogTargetFormatRaw captures enum value "raw"
	LogTargetFormatRaw string = "raw"
)
View Source 
const (

	// LogTargetLevelEmerg captures enum value "emerg"
	LogTargetLevelEmerg string = "emerg"

	// LogTargetLevelAlert captures enum value "alert"
	LogTargetLevelAlert string = "alert"

	// LogTargetLevelCrit captures enum value "crit"
	LogTargetLevelCrit string = "crit"

	// LogTargetLevelErr captures enum value "err"
	LogTargetLevelErr string = "err"

	// LogTargetLevelWarning captures enum value "warning"
	LogTargetLevelWarning string = "warning"

	// LogTargetLevelNotice captures enum value "notice"
	LogTargetLevelNotice string = "notice"

	// LogTargetLevelInfo captures enum value "info"
	LogTargetLevelInfo string = "info"

	// LogTargetLevelDebug captures enum value "debug"
	LogTargetLevelDebug string = "debug"
)
View Source 
const (

	// LogTargetMinlevelEmerg captures enum value "emerg"
	LogTargetMinlevelEmerg string = "emerg"

	// LogTargetMinlevelAlert captures enum value "alert"
	LogTargetMinlevelAlert string = "alert"

	// LogTargetMinlevelCrit captures enum value "crit"
	LogTargetMinlevelCrit string = "crit"

	// LogTargetMinlevelErr captures enum value "err"
	LogTargetMinlevelErr string = "err"

	// LogTargetMinlevelWarning captures enum value "warning"
	LogTargetMinlevelWarning string = "warning"

	// LogTargetMinlevelNotice captures enum value "notice"
	LogTargetMinlevelNotice string = "notice"

	// LogTargetMinlevelInfo captures enum value "info"
	LogTargetMinlevelInfo string = "info"

	// LogTargetMinlevelDebug captures enum value "debug"
	LogTargetMinlevelDebug string = "debug"
)
View Source 
const (

	// MonitorFailCondIf captures enum value "if"
	MonitorFailCondIf string = "if"

	// MonitorFailCondUnless captures enum value "unless"
	MonitorFailCondUnless string = "unless"
)
View Source 
const (

	// MysqlCheckParamsClientVersionPreDash41 captures enum value "pre-41"
	MysqlCheckParamsClientVersionPreDash41 string = "pre-41"

	// MysqlCheckParamsClientVersionPostDash41 captures enum value "post-41"
	MysqlCheckParamsClientVersionPostDash41 string = "post-41"
)
View Source 
const (

	// NativeStatTypeBackend captures enum value "backend"
	NativeStatTypeBackend string = "backend"

	// NativeStatTypeServer captures enum value "server"
	NativeStatTypeServer string = "server"

	// NativeStatTypeFrontend captures enum value "frontend"
	NativeStatTypeFrontend string = "frontend"
)
View Source 
const (

	// NativeStatStatsAgentStatusUNK captures enum value "UNK"
	NativeStatStatsAgentStatusUNK string = "UNK"

	// NativeStatStatsAgentStatusINI captures enum value "INI"
	NativeStatStatsAgentStatusINI string = "INI"

	// NativeStatStatsAgentStatusSOCKERR captures enum value "SOCKERR"
	NativeStatStatsAgentStatusSOCKERR string = "SOCKERR"

	// NativeStatStatsAgentStatusL4OK captures enum value "L4OK"
	NativeStatStatsAgentStatusL4OK string = "L4OK"

	// NativeStatStatsAgentStatusL4TOUT captures enum value "L4TOUT"
	NativeStatStatsAgentStatusL4TOUT string = "L4TOUT"

	// NativeStatStatsAgentStatusL4CON captures enum value "L4CON"
	NativeStatStatsAgentStatusL4CON string = "L4CON"

	// NativeStatStatsAgentStatusL7OK captures enum value "L7OK"
	NativeStatStatsAgentStatusL7OK string = "L7OK"

	// NativeStatStatsAgentStatusL7STS captures enum value "L7STS"
	NativeStatStatsAgentStatusL7STS string = "L7STS"
)
View Source 
const (

	// NativeStatStatsCheckStatusUNK captures enum value "UNK"
	NativeStatStatsCheckStatusUNK string = "UNK"

	// NativeStatStatsCheckStatusINI captures enum value "INI"
	NativeStatStatsCheckStatusINI string = "INI"

	// NativeStatStatsCheckStatusSOCKERR captures enum value "SOCKERR"
	NativeStatStatsCheckStatusSOCKERR string = "SOCKERR"

	// NativeStatStatsCheckStatusL4OK captures enum value "L4OK"
	NativeStatStatsCheckStatusL4OK string = "L4OK"

	// NativeStatStatsCheckStatusL4TOUT captures enum value "L4TOUT"
	NativeStatStatsCheckStatusL4TOUT string = "L4TOUT"

	// NativeStatStatsCheckStatusL4CON captures enum value "L4CON"
	NativeStatStatsCheckStatusL4CON string = "L4CON"

	// NativeStatStatsCheckStatusL6OK captures enum value "L6OK"
	NativeStatStatsCheckStatusL6OK string = "L6OK"

	// NativeStatStatsCheckStatusL6TOUT captures enum value "L6TOUT"
	NativeStatStatsCheckStatusL6TOUT string = "L6TOUT"

	// NativeStatStatsCheckStatusL6RSP captures enum value "L6RSP"
	NativeStatStatsCheckStatusL6RSP string = "L6RSP"

	// NativeStatStatsCheckStatusL7OK captures enum value "L7OK"
	NativeStatStatsCheckStatusL7OK string = "L7OK"

	// NativeStatStatsCheckStatusL7OKC captures enum value "L7OKC"
	NativeStatStatsCheckStatusL7OKC string = "L7OKC"

	// NativeStatStatsCheckStatusL7TOUT captures enum value "L7TOUT"
	NativeStatStatsCheckStatusL7TOUT string = "L7TOUT"

	// NativeStatStatsCheckStatusL7RSP captures enum value "L7RSP"
	NativeStatStatsCheckStatusL7RSP string = "L7RSP"

	// NativeStatStatsCheckStatusL7STS captures enum value "L7STS"
	NativeStatStatsCheckStatusL7STS string = "L7STS"
)
View Source 
const (

	// NativeStatStatsModeTCP captures enum value "tcp"
	NativeStatStatsModeTCP string = "tcp"

	// NativeStatStatsModeHTTP captures enum value "http"
	NativeStatStatsModeHTTP string = "http"

	// NativeStatStatsModeHealth captures enum value "health"
	NativeStatStatsModeHealth string = "health"

	// NativeStatStatsModeUnknown captures enum value "unknown"
	NativeStatStatsModeUnknown string = "unknown"
)
View Source 
const (

	// NativeStatStatsStatusUP captures enum value "UP"
	NativeStatStatsStatusUP string = "UP"

	// NativeStatStatsStatusDOWN captures enum value "DOWN"
	NativeStatStatsStatusDOWN string = "DOWN"

	// NativeStatStatsStatusNOLB captures enum value "NOLB"
	NativeStatStatsStatusNOLB string = "NOLB"

	// NativeStatStatsStatusMAINT captures enum value "MAINT"
	NativeStatStatsStatusMAINT string = "MAINT"

	// NativeStatStatsStatusNoCheck captures enum value "no check"
	NativeStatStatsStatusNoCheck string = "no check"
)
View Source 
const (

	// ProgramStartOnReloadEnabled captures enum value "enabled"
	ProgramStartOnReloadEnabled string = "enabled"

	// ProgramStartOnReloadDisabled captures enum value "disabled"
	ProgramStartOnReloadDisabled string = "disabled"
)
View Source 
const (

	// RedispatchEnabledEnabled captures enum value "enabled"
	RedispatchEnabledEnabled string = "enabled"

	// RedispatchEnabledDisabled captures enum value "disabled"
	RedispatchEnabledDisabled string = "disabled"
)
View Source 
const (

	// ReloadStatusFailed captures enum value "failed"
	ReloadStatusFailed string = "failed"

	// ReloadStatusInProgress captures enum value "in_progress"
	ReloadStatusInProgress string = "in_progress"

	// ReloadStatusSucceeded captures enum value "succeeded"
	ReloadStatusSucceeded string = "succeeded"
)
View Source 
const (

	// RingFormatIso captures enum value "iso"
	RingFormatIso string = "iso"

	// RingFormatLocal captures enum value "local"
	RingFormatLocal string = "local"

	// RingFormatRaw captures enum value "raw"
	RingFormatRaw string = "raw"

	// RingFormatRfc3164 captures enum value "rfc3164"
	RingFormatRfc3164 string = "rfc3164"

	// RingFormatRfc5424 captures enum value "rfc5424"
	RingFormatRfc5424 string = "rfc5424"

	// RingFormatShort captures enum value "short"
	RingFormatShort string = "short"

	// RingFormatPriority captures enum value "priority"
	RingFormatPriority string = "priority"

	// RingFormatTimed captures enum value "timed"
	RingFormatTimed string = "timed"
)
View Source 
const (

	// RuntimeAddServerAgentCheckEnabled captures enum value "enabled"
	RuntimeAddServerAgentCheckEnabled string = "enabled"

	// RuntimeAddServerAgentCheckDisabled captures enum value "disabled"
	RuntimeAddServerAgentCheckDisabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerBackupEnabled captures enum value "enabled"
	RuntimeAddServerBackupEnabled string = "enabled"

	// RuntimeAddServerBackupDisabled captures enum value "disabled"
	RuntimeAddServerBackupDisabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerCheckEnabled captures enum value "enabled"
	RuntimeAddServerCheckEnabled string = "enabled"

	// RuntimeAddServerCheckDisabled captures enum value "disabled"
	RuntimeAddServerCheckDisabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerCheckSendProxyEnabled captures enum value "enabled"
	RuntimeAddServerCheckSendProxyEnabled string = "enabled"

	// RuntimeAddServerCheckSendProxyDisabled captures enum value "disabled"
	RuntimeAddServerCheckSendProxyDisabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerCheckSslEnabled captures enum value "enabled"
	RuntimeAddServerCheckSslEnabled string = "enabled"

	// RuntimeAddServerCheckSslDisabled captures enum value "disabled"
	RuntimeAddServerCheckSslDisabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerCheckViaSocks4Enabled captures enum value "enabled"
	RuntimeAddServerCheckViaSocks4Enabled string = "enabled"

	// RuntimeAddServerCheckViaSocks4Disabled captures enum value "disabled"
	RuntimeAddServerCheckViaSocks4Disabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerForceSslv3Enabled captures enum value "enabled"
	RuntimeAddServerForceSslv3Enabled string = "enabled"

	// RuntimeAddServerForceSslv3Disabled captures enum value "disabled"
	RuntimeAddServerForceSslv3Disabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerForceTlsv10Enabled captures enum value "enabled"
	RuntimeAddServerForceTlsv10Enabled string = "enabled"

	// RuntimeAddServerForceTlsv10Disabled captures enum value "disabled"
	RuntimeAddServerForceTlsv10Disabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerForceTlsv11Enabled captures enum value "enabled"
	RuntimeAddServerForceTlsv11Enabled string = "enabled"

	// RuntimeAddServerForceTlsv11Disabled captures enum value "disabled"
	RuntimeAddServerForceTlsv11Disabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerForceTlsv12Enabled captures enum value "enabled"
	RuntimeAddServerForceTlsv12Enabled string = "enabled"

	// RuntimeAddServerForceTlsv12Disabled captures enum value "disabled"
	RuntimeAddServerForceTlsv12Disabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerForceTlsv13Enabled captures enum value "enabled"
	RuntimeAddServerForceTlsv13Enabled string = "enabled"

	// RuntimeAddServerForceTlsv13Disabled captures enum value "disabled"
	RuntimeAddServerForceTlsv13Disabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerMaintenanceEnabled captures enum value "enabled"
	RuntimeAddServerMaintenanceEnabled string = "enabled"

	// RuntimeAddServerMaintenanceDisabled captures enum value "disabled"
	RuntimeAddServerMaintenanceDisabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerNoSslv3Enabled captures enum value "enabled"
	RuntimeAddServerNoSslv3Enabled string = "enabled"

	// RuntimeAddServerNoSslv3Disabled captures enum value "disabled"
	RuntimeAddServerNoSslv3Disabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerNoTlsv10Enabled captures enum value "enabled"
	RuntimeAddServerNoTlsv10Enabled string = "enabled"

	// RuntimeAddServerNoTlsv10Disabled captures enum value "disabled"
	RuntimeAddServerNoTlsv10Disabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerNoTlsv11Enabled captures enum value "enabled"
	RuntimeAddServerNoTlsv11Enabled string = "enabled"

	// RuntimeAddServerNoTlsv11Disabled captures enum value "disabled"
	RuntimeAddServerNoTlsv11Disabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerNoTlsv12Enabled captures enum value "enabled"
	RuntimeAddServerNoTlsv12Enabled string = "enabled"

	// RuntimeAddServerNoTlsv12Disabled captures enum value "disabled"
	RuntimeAddServerNoTlsv12Disabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerNoTlsv13Enabled captures enum value "enabled"
	RuntimeAddServerNoTlsv13Enabled string = "enabled"

	// RuntimeAddServerNoTlsv13Disabled captures enum value "disabled"
	RuntimeAddServerNoTlsv13Disabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerObserveLayer4 captures enum value "layer4"
	RuntimeAddServerObserveLayer4 string = "layer4"

	// RuntimeAddServerObserveLayer7 captures enum value "layer7"
	RuntimeAddServerObserveLayer7 string = "layer7"
)
View Source 
const (

	// RuntimeAddServerOnErrorFastinter captures enum value "fastinter"
	RuntimeAddServerOnErrorFastinter string = "fastinter"

	// RuntimeAddServerOnErrorFailDashCheck captures enum value "fail-check"
	RuntimeAddServerOnErrorFailDashCheck string = "fail-check"

	// RuntimeAddServerOnErrorSuddenDashDeath captures enum value "sudden-death"
	RuntimeAddServerOnErrorSuddenDashDeath string = "sudden-death"

	// RuntimeAddServerOnErrorMarkDashDown captures enum value "mark-down"
	RuntimeAddServerOnErrorMarkDashDown string = "mark-down"
)
View Source 
const (

	// RuntimeAddServerSendProxyEnabled captures enum value "enabled"
	RuntimeAddServerSendProxyEnabled string = "enabled"

	// RuntimeAddServerSendProxyDisabled captures enum value "disabled"
	RuntimeAddServerSendProxyDisabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerSendProxyV2Enabled captures enum value "enabled"
	RuntimeAddServerSendProxyV2Enabled string = "enabled"

	// RuntimeAddServerSendProxyV2Disabled captures enum value "disabled"
	RuntimeAddServerSendProxyV2Disabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerSendProxyV2SslEnabled captures enum value "enabled"
	RuntimeAddServerSendProxyV2SslEnabled string = "enabled"

	// RuntimeAddServerSendProxyV2SslDisabled captures enum value "disabled"
	RuntimeAddServerSendProxyV2SslDisabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerSendProxyV2SslCnEnabled captures enum value "enabled"
	RuntimeAddServerSendProxyV2SslCnEnabled string = "enabled"

	// RuntimeAddServerSendProxyV2SslCnDisabled captures enum value "disabled"
	RuntimeAddServerSendProxyV2SslCnDisabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerSslEnabled captures enum value "enabled"
	RuntimeAddServerSslEnabled string = "enabled"

	// RuntimeAddServerSslDisabled captures enum value "disabled"
	RuntimeAddServerSslDisabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerSslMaxVerSSLv3 captures enum value "SSLv3"
	RuntimeAddServerSslMaxVerSSLv3 string = "SSLv3"

	// RuntimeAddServerSslMaxVerTLSv1Dot0 captures enum value "TLSv1.0"
	RuntimeAddServerSslMaxVerTLSv1Dot0 string = "TLSv1.0"

	// RuntimeAddServerSslMaxVerTLSv1Dot1 captures enum value "TLSv1.1"
	RuntimeAddServerSslMaxVerTLSv1Dot1 string = "TLSv1.1"

	// RuntimeAddServerSslMaxVerTLSv1Dot2 captures enum value "TLSv1.2"
	RuntimeAddServerSslMaxVerTLSv1Dot2 string = "TLSv1.2"

	// RuntimeAddServerSslMaxVerTLSv1Dot3 captures enum value "TLSv1.3"
	RuntimeAddServerSslMaxVerTLSv1Dot3 string = "TLSv1.3"
)
View Source 
const (

	// RuntimeAddServerSslMinVerSSLv3 captures enum value "SSLv3"
	RuntimeAddServerSslMinVerSSLv3 string = "SSLv3"

	// RuntimeAddServerSslMinVerTLSv1Dot0 captures enum value "TLSv1.0"
	RuntimeAddServerSslMinVerTLSv1Dot0 string = "TLSv1.0"

	// RuntimeAddServerSslMinVerTLSv1Dot1 captures enum value "TLSv1.1"
	RuntimeAddServerSslMinVerTLSv1Dot1 string = "TLSv1.1"

	// RuntimeAddServerSslMinVerTLSv1Dot2 captures enum value "TLSv1.2"
	RuntimeAddServerSslMinVerTLSv1Dot2 string = "TLSv1.2"

	// RuntimeAddServerSslMinVerTLSv1Dot3 captures enum value "TLSv1.3"
	RuntimeAddServerSslMinVerTLSv1Dot3 string = "TLSv1.3"
)
View Source 
const (

	// RuntimeAddServerSslReuseEnabled captures enum value "enabled"
	RuntimeAddServerSslReuseEnabled string = "enabled"

	// RuntimeAddServerSslReuseDisabled captures enum value "disabled"
	RuntimeAddServerSslReuseDisabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerTfoEnabled captures enum value "enabled"
	RuntimeAddServerTfoEnabled string = "enabled"

	// RuntimeAddServerTfoDisabled captures enum value "disabled"
	RuntimeAddServerTfoDisabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerTLSTicketsEnabled captures enum value "enabled"
	RuntimeAddServerTLSTicketsEnabled string = "enabled"

	// RuntimeAddServerTLSTicketsDisabled captures enum value "disabled"
	RuntimeAddServerTLSTicketsDisabled string = "disabled"
)
View Source 
const (

	// RuntimeAddServerVerifyNone captures enum value "none"
	RuntimeAddServerVerifyNone string = "none"

	// RuntimeAddServerVerifyRequired captures enum value "required"
	RuntimeAddServerVerifyRequired string = "required"
)
View Source 
const (

	// RuntimeAddServerWsAuto captures enum value "auto"
	RuntimeAddServerWsAuto string = "auto"

	// RuntimeAddServerWsH1 captures enum value "h1"
	RuntimeAddServerWsH1 string = "h1"

	// RuntimeAddServerWsH2 captures enum value "h2"
	RuntimeAddServerWsH2 string = "h2"
)
View Source 
const (

	// RuntimeServerAdminStateReady captures enum value "ready"
	RuntimeServerAdminStateReady string = "ready"

	// RuntimeServerAdminStateMaint captures enum value "maint"
	RuntimeServerAdminStateMaint string = "maint"

	// RuntimeServerAdminStateDrain captures enum value "drain"
	RuntimeServerAdminStateDrain string = "drain"
)
View Source 
const (

	// RuntimeServerOperationalStateUp captures enum value "up"
	RuntimeServerOperationalStateUp string = "up"

	// RuntimeServerOperationalStateDown captures enum value "down"
	RuntimeServerOperationalStateDown string = "down"

	// RuntimeServerOperationalStateStopping captures enum value "stopping"
	RuntimeServerOperationalStateStopping string = "stopping"
)
View Source 
const (

	// ServerParamsAgentCheckEnabled captures enum value "enabled"
	ServerParamsAgentCheckEnabled string = "enabled"

	// ServerParamsAgentCheckDisabled captures enum value "disabled"
	ServerParamsAgentCheckDisabled string = "disabled"
)
View Source 
const (

	// ServerParamsBackupEnabled captures enum value "enabled"
	ServerParamsBackupEnabled string = "enabled"

	// ServerParamsBackupDisabled captures enum value "disabled"
	ServerParamsBackupDisabled string = "disabled"
)
View Source 
const (

	// ServerParamsCheckEnabled captures enum value "enabled"
	ServerParamsCheckEnabled string = "enabled"

	// ServerParamsCheckDisabled captures enum value "disabled"
	ServerParamsCheckDisabled string = "disabled"
)
View Source 
const (

	// ServerParamsCheckSendProxyEnabled captures enum value "enabled"
	ServerParamsCheckSendProxyEnabled string = "enabled"

	// ServerParamsCheckSendProxyDisabled captures enum value "disabled"
	ServerParamsCheckSendProxyDisabled string = "disabled"
)
View Source 
const (

	// ServerParamsCheckSslEnabled captures enum value "enabled"
	ServerParamsCheckSslEnabled string = "enabled"

	// ServerParamsCheckSslDisabled captures enum value "disabled"
	ServerParamsCheckSslDisabled string = "disabled"
)
View Source 
const (

	// ServerParamsCheckViaSocks4Enabled captures enum value "enabled"
	ServerParamsCheckViaSocks4Enabled string = "enabled"

	// ServerParamsCheckViaSocks4Disabled captures enum value "disabled"
	ServerParamsCheckViaSocks4Disabled string = "disabled"
)
View Source 
const (

	// ServerParamsForceSslv3Enabled captures enum value "enabled"
	ServerParamsForceSslv3Enabled string = "enabled"

	// ServerParamsForceSslv3Disabled captures enum value "disabled"
	ServerParamsForceSslv3Disabled string = "disabled"
)
View Source 
const (

	// ServerParamsForceTlsv10Enabled captures enum value "enabled"
	ServerParamsForceTlsv10Enabled string = "enabled"

	// ServerParamsForceTlsv10Disabled captures enum value "disabled"
	ServerParamsForceTlsv10Disabled string = "disabled"
)
View Source 
const (

	// ServerParamsForceTlsv11Enabled captures enum value "enabled"
	ServerParamsForceTlsv11Enabled string = "enabled"

	// ServerParamsForceTlsv11Disabled captures enum value "disabled"
	ServerParamsForceTlsv11Disabled string = "disabled"
)
View Source 
const (

	// ServerParamsForceTlsv12Enabled captures enum value "enabled"
	ServerParamsForceTlsv12Enabled string = "enabled"

	// ServerParamsForceTlsv12Disabled captures enum value "disabled"
	ServerParamsForceTlsv12Disabled string = "disabled"
)
View Source 
const (

	// ServerParamsForceTlsv13Enabled captures enum value "enabled"
	ServerParamsForceTlsv13Enabled string = "enabled"

	// ServerParamsForceTlsv13Disabled captures enum value "disabled"
	ServerParamsForceTlsv13Disabled string = "disabled"
)
View Source 
const (

	// ServerParamsLogProtoLegacy captures enum value "legacy"
	ServerParamsLogProtoLegacy string = "legacy"

	// ServerParamsLogProtoOctetDashCount captures enum value "octet-count"
	ServerParamsLogProtoOctetDashCount string = "octet-count"
)
View Source 
const (

	// ServerParamsMaintenanceEnabled captures enum value "enabled"
	ServerParamsMaintenanceEnabled string = "enabled"

	// ServerParamsMaintenanceDisabled captures enum value "disabled"
	ServerParamsMaintenanceDisabled string = "disabled"
)
View Source 
const (

	// ServerParamsNoSslv3Enabled captures enum value "enabled"
	ServerParamsNoSslv3Enabled string = "enabled"

	// ServerParamsNoSslv3Disabled captures enum value "disabled"
	ServerParamsNoSslv3Disabled string = "disabled"
)
View Source 
const (

	// ServerParamsNoTlsv10Enabled captures enum value "enabled"
	ServerParamsNoTlsv10Enabled string = "enabled"

	// ServerParamsNoTlsv10Disabled captures enum value "disabled"
	ServerParamsNoTlsv10Disabled string = "disabled"
)
View Source 
const (

	// ServerParamsNoTlsv11Enabled captures enum value "enabled"
	ServerParamsNoTlsv11Enabled string = "enabled"

	// ServerParamsNoTlsv11Disabled captures enum value "disabled"
	ServerParamsNoTlsv11Disabled string = "disabled"
)
View Source 
const (

	// ServerParamsNoTlsv12Enabled captures enum value "enabled"
	ServerParamsNoTlsv12Enabled string = "enabled"

	// ServerParamsNoTlsv12Disabled captures enum value "disabled"
	ServerParamsNoTlsv12Disabled string = "disabled"
)
View Source 
const (

	// ServerParamsNoTlsv13Enabled captures enum value "enabled"
	ServerParamsNoTlsv13Enabled string = "enabled"

	// ServerParamsNoTlsv13Disabled captures enum value "disabled"
	ServerParamsNoTlsv13Disabled string = "disabled"
)
View Source 
const (

	// ServerParamsNoVerifyhostEnabled captures enum value "enabled"
	ServerParamsNoVerifyhostEnabled string = "enabled"

	// ServerParamsNoVerifyhostDisabled captures enum value "disabled"
	ServerParamsNoVerifyhostDisabled string = "disabled"
)
View Source 
const (

	// ServerParamsObserveLayer4 captures enum value "layer4"
	ServerParamsObserveLayer4 string = "layer4"

	// ServerParamsObserveLayer7 captures enum value "layer7"
	ServerParamsObserveLayer7 string = "layer7"
)
View Source 
const (

	// ServerParamsOnErrorFastinter captures enum value "fastinter"
	ServerParamsOnErrorFastinter string = "fastinter"

	// ServerParamsOnErrorFailDashCheck captures enum value "fail-check"
	ServerParamsOnErrorFailDashCheck string = "fail-check"

	// ServerParamsOnErrorSuddenDashDeath captures enum value "sudden-death"
	ServerParamsOnErrorSuddenDashDeath string = "sudden-death"

	// ServerParamsOnErrorMarkDashDown captures enum value "mark-down"
	ServerParamsOnErrorMarkDashDown string = "mark-down"
)
View Source 
const (

	// ServerParamsResolvePreferIPV4 captures enum value "ipv4"
	ServerParamsResolvePreferIPV4 string = "ipv4"

	// ServerParamsResolvePreferIPV6 captures enum value "ipv6"
	ServerParamsResolvePreferIPV6 string = "ipv6"
)
View Source 
const (

	// ServerParamsSendProxyEnabled captures enum value "enabled"
	ServerParamsSendProxyEnabled string = "enabled"

	// ServerParamsSendProxyDisabled captures enum value "disabled"
	ServerParamsSendProxyDisabled string = "disabled"
)
View Source 
const (

	// ServerParamsSendProxyV2Enabled captures enum value "enabled"
	ServerParamsSendProxyV2Enabled string = "enabled"

	// ServerParamsSendProxyV2Disabled captures enum value "disabled"
	ServerParamsSendProxyV2Disabled string = "disabled"
)
View Source 
const (

	// ServerParamsSendProxyV2SslEnabled captures enum value "enabled"
	ServerParamsSendProxyV2SslEnabled string = "enabled"

	// ServerParamsSendProxyV2SslDisabled captures enum value "disabled"
	ServerParamsSendProxyV2SslDisabled string = "disabled"
)
View Source 
const (

	// ServerParamsSendProxyV2SslCnEnabled captures enum value "enabled"
	ServerParamsSendProxyV2SslCnEnabled string = "enabled"

	// ServerParamsSendProxyV2SslCnDisabled captures enum value "disabled"
	ServerParamsSendProxyV2SslCnDisabled string = "disabled"
)
View Source 
const (

	// ServerParamsSslEnabled captures enum value "enabled"
	ServerParamsSslEnabled string = "enabled"

	// ServerParamsSslDisabled captures enum value "disabled"
	ServerParamsSslDisabled string = "disabled"
)
View Source 
const (

	// ServerParamsSslMaxVerSSLv3 captures enum value "SSLv3"
	ServerParamsSslMaxVerSSLv3 string = "SSLv3"

	// ServerParamsSslMaxVerTLSv1Dot0 captures enum value "TLSv1.0"
	ServerParamsSslMaxVerTLSv1Dot0 string = "TLSv1.0"

	// ServerParamsSslMaxVerTLSv1Dot1 captures enum value "TLSv1.1"
	ServerParamsSslMaxVerTLSv1Dot1 string = "TLSv1.1"

	// ServerParamsSslMaxVerTLSv1Dot2 captures enum value "TLSv1.2"
	ServerParamsSslMaxVerTLSv1Dot2 string = "TLSv1.2"

	// ServerParamsSslMaxVerTLSv1Dot3 captures enum value "TLSv1.3"
	ServerParamsSslMaxVerTLSv1Dot3 string = "TLSv1.3"
)
View Source 
const (

	// ServerParamsSslMinVerSSLv3 captures enum value "SSLv3"
	ServerParamsSslMinVerSSLv3 string = "SSLv3"

	// ServerParamsSslMinVerTLSv1Dot0 captures enum value "TLSv1.0"
	ServerParamsSslMinVerTLSv1Dot0 string = "TLSv1.0"

	// ServerParamsSslMinVerTLSv1Dot1 captures enum value "TLSv1.1"
	ServerParamsSslMinVerTLSv1Dot1 string = "TLSv1.1"

	// ServerParamsSslMinVerTLSv1Dot2 captures enum value "TLSv1.2"
	ServerParamsSslMinVerTLSv1Dot2 string = "TLSv1.2"

	// ServerParamsSslMinVerTLSv1Dot3 captures enum value "TLSv1.3"
	ServerParamsSslMinVerTLSv1Dot3 string = "TLSv1.3"
)
View Source 
const (

	// ServerParamsSslReuseEnabled captures enum value "enabled"
	ServerParamsSslReuseEnabled string = "enabled"

	// ServerParamsSslReuseDisabled captures enum value "disabled"
	ServerParamsSslReuseDisabled string = "disabled"
)
View Source 
const (

	// ServerParamsStickEnabled captures enum value "enabled"
	ServerParamsStickEnabled string = "enabled"

	// ServerParamsStickDisabled captures enum value "disabled"
	ServerParamsStickDisabled string = "disabled"
)
View Source 
const (

	// ServerParamsTfoEnabled captures enum value "enabled"
	ServerParamsTfoEnabled string = "enabled"

	// ServerParamsTfoDisabled captures enum value "disabled"
	ServerParamsTfoDisabled string = "disabled"
)
View Source 
const (

	// ServerParamsTLSTicketsEnabled captures enum value "enabled"
	ServerParamsTLSTicketsEnabled string = "enabled"

	// ServerParamsTLSTicketsDisabled captures enum value "disabled"
	ServerParamsTLSTicketsDisabled string = "disabled"
)
View Source 
const (

	// ServerParamsVerifyNone captures enum value "none"
	ServerParamsVerifyNone string = "none"

	// ServerParamsVerifyRequired captures enum value "required"
	ServerParamsVerifyRequired string = "required"
)
View Source 
const (

	// ServerParamsWsAuto captures enum value "auto"
	ServerParamsWsAuto string = "auto"

	// ServerParamsWsH1 captures enum value "h1"
	ServerParamsWsH1 string = "h1"

	// ServerParamsWsH2 captures enum value "h2"
	ServerParamsWsH2 string = "h2"
)
View Source 
const (

	// ServerSwitchingRuleCondIf captures enum value "if"
	ServerSwitchingRuleCondIf string = "if"

	// ServerSwitchingRuleCondUnless captures enum value "unless"
	ServerSwitchingRuleCondUnless string = "unless"
)
View Source 
const (

	// SiteFarmCondIf captures enum value "if"
	SiteFarmCondIf string = "if"

	// SiteFarmCondUnless captures enum value "unless"
	SiteFarmCondUnless string = "unless"
)
View Source 
const (

	// SiteFarmModeHTTP captures enum value "http"
	SiteFarmModeHTTP string = "http"

	// SiteFarmModeTCP captures enum value "tcp"
	SiteFarmModeTCP string = "tcp"
)
View Source 
const (

	// SiteFarmUseAsDefault captures enum value "default"
	SiteFarmUseAsDefault string = "default"

	// SiteFarmUseAsConditional captures enum value "conditional"
	SiteFarmUseAsConditional string = "conditional"
)
View Source 
const (

	// SiteServiceHTTPConnectionModeHTTPDashTunnel captures enum value "http-tunnel"
	SiteServiceHTTPConnectionModeHTTPDashTunnel string = "http-tunnel"

	// SiteServiceHTTPConnectionModeHttpclose captures enum value "httpclose"
	SiteServiceHTTPConnectionModeHttpclose string = "httpclose"

	// SiteServiceHTTPConnectionModeForcedDashClose captures enum value "forced-close"
	SiteServiceHTTPConnectionModeForcedDashClose string = "forced-close"

	// SiteServiceHTTPConnectionModeHTTPDashServerDashClose captures enum value "http-server-close"
	SiteServiceHTTPConnectionModeHTTPDashServerDashClose string = "http-server-close"

	// SiteServiceHTTPConnectionModeHTTPDashKeepDashAlive captures enum value "http-keep-alive"
	SiteServiceHTTPConnectionModeHTTPDashKeepDashAlive string = "http-keep-alive"
)
View Source 
const (

	// SiteServiceModeHTTP captures enum value "http"
	SiteServiceModeHTTP string = "http"

	// SiteServiceModeTCP captures enum value "tcp"
	SiteServiceModeTCP string = "tcp"
)
View Source 
const (

	// SourceUsesrcAddress captures enum value "address"
	SourceUsesrcAddress string = "address"

	// SourceUsesrcClient captures enum value "client"
	SourceUsesrcClient string = "client"

	// SourceUsesrcClientip captures enum value "clientip"
	SourceUsesrcClientip string = "clientip"

	// SourceUsesrcHdrIP captures enum value "hdr_ip"
	SourceUsesrcHdrIP string = "hdr_ip"
)
View Source 
const (

	// SpoeAgentAsyncEnabled captures enum value "enabled"
	SpoeAgentAsyncEnabled string = "enabled"

	// SpoeAgentAsyncDisabled captures enum value "disabled"
	SpoeAgentAsyncDisabled string = "disabled"
)
View Source 
const (

	// SpoeAgentDontlogNormalEnabled captures enum value "enabled"
	SpoeAgentDontlogNormalEnabled string = "enabled"

	// SpoeAgentDontlogNormalDisabled captures enum value "disabled"
	SpoeAgentDontlogNormalDisabled string = "disabled"
)
View Source 
const (

	// SpoeAgentPipeliningEnabled captures enum value "enabled"
	SpoeAgentPipeliningEnabled string = "enabled"

	// SpoeAgentPipeliningDisabled captures enum value "disabled"
	SpoeAgentPipeliningDisabled string = "disabled"
)
View Source 
const (

	// SpoeAgentSendFragPayloadEnabled captures enum value "enabled"
	SpoeAgentSendFragPayloadEnabled string = "enabled"

	// SpoeAgentSendFragPayloadDisabled captures enum value "disabled"
	SpoeAgentSendFragPayloadDisabled string = "disabled"
)
View Source 
const (

	// SpoeMessageEventCondIf captures enum value "if"
	SpoeMessageEventCondIf string = "if"

	// SpoeMessageEventCondUnless captures enum value "unless"
	SpoeMessageEventCondUnless string = "unless"
)
View Source 
const (

	// SpoeMessageEventNameOnDashBackendDashHTTPDashRequest captures enum value "on-backend-http-request"
	SpoeMessageEventNameOnDashBackendDashHTTPDashRequest string = "on-backend-http-request"

	// SpoeMessageEventNameOnDashBackendDashTCPDashRequest captures enum value "on-backend-tcp-request"
	SpoeMessageEventNameOnDashBackendDashTCPDashRequest string = "on-backend-tcp-request"

	// SpoeMessageEventNameOnDashClientDashSession captures enum value "on-client-session"
	SpoeMessageEventNameOnDashClientDashSession string = "on-client-session"

	// SpoeMessageEventNameOnDashFrontendDashHTTPDashRequest captures enum value "on-frontend-http-request"
	SpoeMessageEventNameOnDashFrontendDashHTTPDashRequest string = "on-frontend-http-request"

	// SpoeMessageEventNameOnDashFrontendDashTCPDashRequest captures enum value "on-frontend-tcp-request"
	SpoeMessageEventNameOnDashFrontendDashTCPDashRequest string = "on-frontend-tcp-request"

	// SpoeMessageEventNameOnDashHTTPDashResponse captures enum value "on-http-response"
	SpoeMessageEventNameOnDashHTTPDashResponse string = "on-http-response"

	// SpoeMessageEventNameOnDashServerDashSession captures enum value "on-server-session"
	SpoeMessageEventNameOnDashServerDashSession string = "on-server-session"

	// SpoeMessageEventNameOnDashTCPDashResponse captures enum value "on-tcp-response"
	SpoeMessageEventNameOnDashTCPDashResponse string = "on-tcp-response"
)
View Source 
const (

	// SpoeTransactionStatusFailed captures enum value "failed"
	SpoeTransactionStatusFailed string = "failed"

	// SpoeTransactionStatusInProgress captures enum value "in_progress"
	SpoeTransactionStatusInProgress string = "in_progress"

	// SpoeTransactionStatusSuccess captures enum value "success"
	SpoeTransactionStatusSuccess string = "success"
)
View Source 
const (

	// StatsHTTPRequestTypeAllow captures enum value "allow"
	StatsHTTPRequestTypeAllow string = "allow"

	// StatsHTTPRequestTypeDeny captures enum value "deny"
	StatsHTTPRequestTypeDeny string = "deny"

	// StatsHTTPRequestTypeAuth captures enum value "auth"
	StatsHTTPRequestTypeAuth string = "auth"
)
View Source 
const (

	// StatsOptionsStatsAdminCondIf captures enum value "if"
	StatsOptionsStatsAdminCondIf string = "if"

	// StatsOptionsStatsAdminCondUnless captures enum value "unless"
	StatsOptionsStatsAdminCondUnless string = "unless"
)
View Source 
const (

	// StickRuleCondIf captures enum value "if"
	StickRuleCondIf string = "if"

	// StickRuleCondUnless captures enum value "unless"
	StickRuleCondUnless string = "unless"
)
View Source 
const (

	// StickRuleTypeMatch captures enum value "match"
	StickRuleTypeMatch string = "match"

	// StickRuleTypeOn captures enum value "on"
	StickRuleTypeOn string = "on"

	// StickRuleTypeStoreDashRequest captures enum value "store-request"
	StickRuleTypeStoreDashRequest string = "store-request"

	// StickRuleTypeStoreDashResponse captures enum value "store-response"
	StickRuleTypeStoreDashResponse string = "store-response"
)
View Source 
const (

	// StickTableTypeIP captures enum value "ip"
	StickTableTypeIP string = "ip"

	// StickTableTypeIPV6 captures enum value "ipv6"
	StickTableTypeIPV6 string = "ipv6"

	// StickTableTypeInteger captures enum value "integer"
	StickTableTypeInteger string = "integer"

	// StickTableTypeString captures enum value "string"
	StickTableTypeString string = "string"

	// StickTableTypeBinary captures enum value "binary"
	StickTableTypeBinary string = "binary"
)
View Source 
const (

	// StickTableFieldFieldBytesInCnt captures enum value "bytes_in_cnt"
	StickTableFieldFieldBytesInCnt string = "bytes_in_cnt"

	// StickTableFieldFieldBytesInRate captures enum value "bytes_in_rate"
	StickTableFieldFieldBytesInRate string = "bytes_in_rate"

	// StickTableFieldFieldBytesOutCnt captures enum value "bytes_out_cnt"
	StickTableFieldFieldBytesOutCnt string = "bytes_out_cnt"

	// StickTableFieldFieldBytesOutRate captures enum value "bytes_out_rate"
	StickTableFieldFieldBytesOutRate string = "bytes_out_rate"

	// StickTableFieldFieldConnCnt captures enum value "conn_cnt"
	StickTableFieldFieldConnCnt string = "conn_cnt"

	// StickTableFieldFieldConnCur captures enum value "conn_cur"
	StickTableFieldFieldConnCur string = "conn_cur"

	// StickTableFieldFieldConnRate captures enum value "conn_rate"
	StickTableFieldFieldConnRate string = "conn_rate"

	// StickTableFieldFieldGpc0 captures enum value "gpc0"
	StickTableFieldFieldGpc0 string = "gpc0"

	// StickTableFieldFieldGpc0Rate captures enum value "gpc0_rate"
	StickTableFieldFieldGpc0Rate string = "gpc0_rate"

	// StickTableFieldFieldGpc1 captures enum value "gpc1"
	StickTableFieldFieldGpc1 string = "gpc1"

	// StickTableFieldFieldGpc1Rate captures enum value "gpc1_rate"
	StickTableFieldFieldGpc1Rate string = "gpc1_rate"

	// StickTableFieldFieldGpt0 captures enum value "gpt0"
	StickTableFieldFieldGpt0 string = "gpt0"

	// StickTableFieldFieldHTTPReqCnt captures enum value "http_req_cnt"
	StickTableFieldFieldHTTPReqCnt string = "http_req_cnt"

	// StickTableFieldFieldHTTPReqRate captures enum value "http_req_rate"
	StickTableFieldFieldHTTPReqRate string = "http_req_rate"

	// StickTableFieldFieldHTTPErrCnt captures enum value "http_err_cnt"
	StickTableFieldFieldHTTPErrCnt string = "http_err_cnt"

	// StickTableFieldFieldHTTPErrRate captures enum value "http_err_rate"
	StickTableFieldFieldHTTPErrRate string = "http_err_rate"

	// StickTableFieldFieldServerID captures enum value "server_id"
	StickTableFieldFieldServerID string = "server_id"

	// StickTableFieldFieldSessCnt captures enum value "sess_cnt"
	StickTableFieldFieldSessCnt string = "sess_cnt"

	// StickTableFieldFieldSessRate captures enum value "sess_rate"
	StickTableFieldFieldSessRate string = "sess_rate"
)
View Source 
const (

	// StickTableFieldTypeRate captures enum value "rate"
	StickTableFieldTypeRate string = "rate"

	// StickTableFieldTypeCounter captures enum value "counter"
	StickTableFieldTypeCounter string = "counter"
)
View Source 
const (

	// TableTypeIP captures enum value "ip"
	TableTypeIP string = "ip"

	// TableTypeInteger captures enum value "integer"
	TableTypeInteger string = "integer"

	// TableTypeString captures enum value "string"
	TableTypeString string = "string"

	// TableTypeBinary captures enum value "binary"
	TableTypeBinary string = "binary"
)
View Source 
const (

	// TCPCheckActionComment captures enum value "comment"
	TCPCheckActionComment string = "comment"

	// TCPCheckActionConnect captures enum value "connect"
	TCPCheckActionConnect string = "connect"

	// TCPCheckActionExpect captures enum value "expect"
	TCPCheckActionExpect string = "expect"

	// TCPCheckActionSend captures enum value "send"
	TCPCheckActionSend string = "send"

	// TCPCheckActionSendDashLf captures enum value "send-lf"
	TCPCheckActionSendDashLf string = "send-lf"

	// TCPCheckActionSendDashBinary captures enum value "send-binary"
	TCPCheckActionSendDashBinary string = "send-binary"

	// TCPCheckActionSendDashBinaryDashLf captures enum value "send-binary-lf"
	TCPCheckActionSendDashBinaryDashLf string = "send-binary-lf"

	// TCPCheckActionSetDashVar captures enum value "set-var"
	TCPCheckActionSetDashVar string = "set-var"

	// TCPCheckActionSetDashVarDashFmt captures enum value "set-var-fmt"
	TCPCheckActionSetDashVarDashFmt string = "set-var-fmt"

	// TCPCheckActionUnsetDashVar captures enum value "unset-var"
	TCPCheckActionUnsetDashVar string = "unset-var"
)
View Source 
const (

	// TCPCheckErrorStatusL7OKC captures enum value "L7OKC"
	TCPCheckErrorStatusL7OKC string = "L7OKC"

	// TCPCheckErrorStatusL7RSP captures enum value "L7RSP"
	TCPCheckErrorStatusL7RSP string = "L7RSP"

	// TCPCheckErrorStatusL7STS captures enum value "L7STS"
	TCPCheckErrorStatusL7STS string = "L7STS"

	// TCPCheckErrorStatusL6RSP captures enum value "L6RSP"
	TCPCheckErrorStatusL6RSP string = "L6RSP"

	// TCPCheckErrorStatusL4CON captures enum value "L4CON"
	TCPCheckErrorStatusL4CON string = "L4CON"
)
View Source 
const (

	// TCPCheckMatchString captures enum value "string"
	TCPCheckMatchString string = "string"

	// TCPCheckMatchRstring captures enum value "rstring"
	TCPCheckMatchRstring string = "rstring"

	// TCPCheckMatchStringDashLf captures enum value "string-lf"
	TCPCheckMatchStringDashLf string = "string-lf"

	// TCPCheckMatchBinary captures enum value "binary"
	TCPCheckMatchBinary string = "binary"

	// TCPCheckMatchRbinary captures enum value "rbinary"
	TCPCheckMatchRbinary string = "rbinary"

	// TCPCheckMatchBinaryDashLf captures enum value "binary-lf"
	TCPCheckMatchBinaryDashLf string = "binary-lf"
)
View Source 
const (

	// TCPCheckOkStatusL7OK captures enum value "L7OK"
	TCPCheckOkStatusL7OK string = "L7OK"

	// TCPCheckOkStatusL7OKC captures enum value "L7OKC"
	TCPCheckOkStatusL7OKC string = "L7OKC"

	// TCPCheckOkStatusL6OK captures enum value "L6OK"
	TCPCheckOkStatusL6OK string = "L6OK"

	// TCPCheckOkStatusL4OK captures enum value "L4OK"
	TCPCheckOkStatusL4OK string = "L4OK"
)
View Source 
const (

	// TCPCheckToutStatusL7TOUT captures enum value "L7TOUT"
	TCPCheckToutStatusL7TOUT string = "L7TOUT"

	// TCPCheckToutStatusL6TOUT captures enum value "L6TOUT"
	TCPCheckToutStatusL6TOUT string = "L6TOUT"

	// TCPCheckToutStatusL4TOUT captures enum value "L4TOUT"
	TCPCheckToutStatusL4TOUT string = "L4TOUT"
)
View Source 
const (

	// TCPRequestRuleActionAccept captures enum value "accept"
	TCPRequestRuleActionAccept string = "accept"

	// TCPRequestRuleActionAttachDashSrv captures enum value "attach-srv"
	TCPRequestRuleActionAttachDashSrv string = "attach-srv"

	// TCPRequestRuleActionCapture captures enum value "capture"
	TCPRequestRuleActionCapture string = "capture"

	// TCPRequestRuleActionDoDashResolve captures enum value "do-resolve"
	TCPRequestRuleActionDoDashResolve string = "do-resolve"

	// TCPRequestRuleActionExpectDashNetscalerDashCip captures enum value "expect-netscaler-cip"
	TCPRequestRuleActionExpectDashNetscalerDashCip string = "expect-netscaler-cip"

	// TCPRequestRuleActionExpectDashProxy captures enum value "expect-proxy"
	TCPRequestRuleActionExpectDashProxy string = "expect-proxy"

	// TCPRequestRuleActionLua captures enum value "lua"
	TCPRequestRuleActionLua string = "lua"

	// TCPRequestRuleActionReject captures enum value "reject"
	TCPRequestRuleActionReject string = "reject"

	// TCPRequestRuleActionScDashAddDashGpc captures enum value "sc-add-gpc"
	TCPRequestRuleActionScDashAddDashGpc string = "sc-add-gpc"

	// TCPRequestRuleActionScDashIncDashGpc captures enum value "sc-inc-gpc"
	TCPRequestRuleActionScDashIncDashGpc string = "sc-inc-gpc"

	// TCPRequestRuleActionScDashIncDashGpc0 captures enum value "sc-inc-gpc0"
	TCPRequestRuleActionScDashIncDashGpc0 string = "sc-inc-gpc0"

	// TCPRequestRuleActionScDashIncDashGpc1 captures enum value "sc-inc-gpc1"
	TCPRequestRuleActionScDashIncDashGpc1 string = "sc-inc-gpc1"

	// TCPRequestRuleActionScDashSetDashGpt captures enum value "sc-set-gpt"
	TCPRequestRuleActionScDashSetDashGpt string = "sc-set-gpt"

	// TCPRequestRuleActionScDashSetDashGpt0 captures enum value "sc-set-gpt0"
	TCPRequestRuleActionScDashSetDashGpt0 string = "sc-set-gpt0"

	// TCPRequestRuleActionSendDashSpoeDashGroup captures enum value "send-spoe-group"
	TCPRequestRuleActionSendDashSpoeDashGroup string = "send-spoe-group"

	// TCPRequestRuleActionSetDashBandwidthDashLimit captures enum value "set-bandwidth-limit"
	TCPRequestRuleActionSetDashBandwidthDashLimit string = "set-bandwidth-limit"

	// TCPRequestRuleActionSetDashDstDashPort captures enum value "set-dst-port"
	TCPRequestRuleActionSetDashDstDashPort string = "set-dst-port"

	// TCPRequestRuleActionSetDashDst captures enum value "set-dst"
	TCPRequestRuleActionSetDashDst string = "set-dst"

	// TCPRequestRuleActionSetDashLogDashLevel captures enum value "set-log-level"
	TCPRequestRuleActionSetDashLogDashLevel string = "set-log-level"

	// TCPRequestRuleActionSetDashMark captures enum value "set-mark"
	TCPRequestRuleActionSetDashMark string = "set-mark"

	// TCPRequestRuleActionSetDashNice captures enum value "set-nice"
	TCPRequestRuleActionSetDashNice string = "set-nice"

	// TCPRequestRuleActionSetDashPriorityDashClass captures enum value "set-priority-class"
	TCPRequestRuleActionSetDashPriorityDashClass string = "set-priority-class"

	// TCPRequestRuleActionSetDashPriorityDashOffset captures enum value "set-priority-offset"
	TCPRequestRuleActionSetDashPriorityDashOffset string = "set-priority-offset"

	// TCPRequestRuleActionSetDashSrc captures enum value "set-src"
	TCPRequestRuleActionSetDashSrc string = "set-src"

	// TCPRequestRuleActionSetDashSrcDashPort captures enum value "set-src-port"
	TCPRequestRuleActionSetDashSrcDashPort string = "set-src-port"

	// TCPRequestRuleActionSetDashTos captures enum value "set-tos"
	TCPRequestRuleActionSetDashTos string = "set-tos"

	// TCPRequestRuleActionSetDashVar captures enum value "set-var"
	TCPRequestRuleActionSetDashVar string = "set-var"

	// TCPRequestRuleActionSetDashVarDashFmt captures enum value "set-var-fmt"
	TCPRequestRuleActionSetDashVarDashFmt string = "set-var-fmt"

	// TCPRequestRuleActionSilentDashDrop captures enum value "silent-drop"
	TCPRequestRuleActionSilentDashDrop string = "silent-drop"

	// TCPRequestRuleActionSwitchDashMode captures enum value "switch-mode"
	TCPRequestRuleActionSwitchDashMode string = "switch-mode"

	// TCPRequestRuleActionTrackDashSc0 captures enum value "track-sc0"
	TCPRequestRuleActionTrackDashSc0 string = "track-sc0"

	// TCPRequestRuleActionTrackDashSc1 captures enum value "track-sc1"
	TCPRequestRuleActionTrackDashSc1 string = "track-sc1"

	// TCPRequestRuleActionTrackDashSc2 captures enum value "track-sc2"
	TCPRequestRuleActionTrackDashSc2 string = "track-sc2"

	// TCPRequestRuleActionTrackDashSc captures enum value "track-sc"
	TCPRequestRuleActionTrackDashSc string = "track-sc"

	// TCPRequestRuleActionUnsetDashVar captures enum value "unset-var"
	TCPRequestRuleActionUnsetDashVar string = "unset-var"

	// TCPRequestRuleActionUseDashService captures enum value "use-service"
	TCPRequestRuleActionUseDashService string = "use-service"
)
View Source 
const (

	// TCPRequestRuleCondIf captures enum value "if"
	TCPRequestRuleCondIf string = "if"

	// TCPRequestRuleCondUnless captures enum value "unless"
	TCPRequestRuleCondUnless string = "unless"
)
View Source 
const (

	// TCPRequestRuleLogLevelEmerg captures enum value "emerg"
	TCPRequestRuleLogLevelEmerg string = "emerg"

	// TCPRequestRuleLogLevelAlert captures enum value "alert"
	TCPRequestRuleLogLevelAlert string = "alert"

	// TCPRequestRuleLogLevelCrit captures enum value "crit"
	TCPRequestRuleLogLevelCrit string = "crit"

	// TCPRequestRuleLogLevelErr captures enum value "err"
	TCPRequestRuleLogLevelErr string = "err"

	// TCPRequestRuleLogLevelWarning captures enum value "warning"
	TCPRequestRuleLogLevelWarning string = "warning"

	// TCPRequestRuleLogLevelNotice captures enum value "notice"
	TCPRequestRuleLogLevelNotice string = "notice"

	// TCPRequestRuleLogLevelInfo captures enum value "info"
	TCPRequestRuleLogLevelInfo string = "info"

	// TCPRequestRuleLogLevelDebug captures enum value "debug"
	TCPRequestRuleLogLevelDebug string = "debug"

	// TCPRequestRuleLogLevelSilent captures enum value "silent"
	TCPRequestRuleLogLevelSilent string = "silent"
)
View Source 
const (

	// TCPRequestRuleResolveProtocolIPV4 captures enum value "ipv4"
	TCPRequestRuleResolveProtocolIPV4 string = "ipv4"

	// TCPRequestRuleResolveProtocolIPV6 captures enum value "ipv6"
	TCPRequestRuleResolveProtocolIPV6 string = "ipv6"
)
View Source 
const (

	// TCPRequestRuleTypeConnection captures enum value "connection"
	TCPRequestRuleTypeConnection string = "connection"

	// TCPRequestRuleTypeContent captures enum value "content"
	TCPRequestRuleTypeContent string = "content"

	// TCPRequestRuleTypeInspectDashDelay captures enum value "inspect-delay"
	TCPRequestRuleTypeInspectDashDelay string = "inspect-delay"

	// TCPRequestRuleTypeSession captures enum value "session"
	TCPRequestRuleTypeSession string = "session"
)
View Source 
const (

	// TCPResponseRuleActionAccept captures enum value "accept"
	TCPResponseRuleActionAccept string = "accept"

	// TCPResponseRuleActionClose captures enum value "close"
	TCPResponseRuleActionClose string = "close"

	// TCPResponseRuleActionLua captures enum value "lua"
	TCPResponseRuleActionLua string = "lua"

	// TCPResponseRuleActionReject captures enum value "reject"
	TCPResponseRuleActionReject string = "reject"

	// TCPResponseRuleActionScDashAddDashGpc captures enum value "sc-add-gpc"
	TCPResponseRuleActionScDashAddDashGpc string = "sc-add-gpc"

	// TCPResponseRuleActionScDashIncDashGpc captures enum value "sc-inc-gpc"
	TCPResponseRuleActionScDashIncDashGpc string = "sc-inc-gpc"

	// TCPResponseRuleActionScDashIncDashGpc0 captures enum value "sc-inc-gpc0"
	TCPResponseRuleActionScDashIncDashGpc0 string = "sc-inc-gpc0"

	// TCPResponseRuleActionScDashIncDashGpc1 captures enum value "sc-inc-gpc1"
	TCPResponseRuleActionScDashIncDashGpc1 string = "sc-inc-gpc1"

	// TCPResponseRuleActionScDashSetDashGpt captures enum value "sc-set-gpt"
	TCPResponseRuleActionScDashSetDashGpt string = "sc-set-gpt"

	// TCPResponseRuleActionScDashSetDashGpt0 captures enum value "sc-set-gpt0"
	TCPResponseRuleActionScDashSetDashGpt0 string = "sc-set-gpt0"

	// TCPResponseRuleActionSendDashSpoeDashGroup captures enum value "send-spoe-group"
	TCPResponseRuleActionSendDashSpoeDashGroup string = "send-spoe-group"

	// TCPResponseRuleActionSetDashBandwidthDashLimit captures enum value "set-bandwidth-limit"
	TCPResponseRuleActionSetDashBandwidthDashLimit string = "set-bandwidth-limit"

	// TCPResponseRuleActionSetDashLogDashLevel captures enum value "set-log-level"
	TCPResponseRuleActionSetDashLogDashLevel string = "set-log-level"

	// TCPResponseRuleActionSetDashMark captures enum value "set-mark"
	TCPResponseRuleActionSetDashMark string = "set-mark"

	// TCPResponseRuleActionSetDashNice captures enum value "set-nice"
	TCPResponseRuleActionSetDashNice string = "set-nice"

	// TCPResponseRuleActionSetDashTos captures enum value "set-tos"
	TCPResponseRuleActionSetDashTos string = "set-tos"

	// TCPResponseRuleActionSetDashVar captures enum value "set-var"
	TCPResponseRuleActionSetDashVar string = "set-var"

	// TCPResponseRuleActionSetDashVarDashFmt captures enum value "set-var-fmt"
	TCPResponseRuleActionSetDashVarDashFmt string = "set-var-fmt"

	// TCPResponseRuleActionSilentDashDrop captures enum value "silent-drop"
	TCPResponseRuleActionSilentDashDrop string = "silent-drop"

	// TCPResponseRuleActionUnsetDashVar captures enum value "unset-var"
	TCPResponseRuleActionUnsetDashVar string = "unset-var"
)
View Source 
const (

	// TCPResponseRuleCondIf captures enum value "if"
	TCPResponseRuleCondIf string = "if"

	// TCPResponseRuleCondUnless captures enum value "unless"
	TCPResponseRuleCondUnless string = "unless"
)
View Source 
const (

	// TCPResponseRuleLogLevelEmerg captures enum value "emerg"
	TCPResponseRuleLogLevelEmerg string = "emerg"

	// TCPResponseRuleLogLevelAlert captures enum value "alert"
	TCPResponseRuleLogLevelAlert string = "alert"

	// TCPResponseRuleLogLevelCrit captures enum value "crit"
	TCPResponseRuleLogLevelCrit string = "crit"

	// TCPResponseRuleLogLevelErr captures enum value "err"
	TCPResponseRuleLogLevelErr string = "err"

	// TCPResponseRuleLogLevelWarning captures enum value "warning"
	TCPResponseRuleLogLevelWarning string = "warning"

	// TCPResponseRuleLogLevelNotice captures enum value "notice"
	TCPResponseRuleLogLevelNotice string = "notice"

	// TCPResponseRuleLogLevelInfo captures enum value "info"
	TCPResponseRuleLogLevelInfo string = "info"

	// TCPResponseRuleLogLevelDebug captures enum value "debug"
	TCPResponseRuleLogLevelDebug string = "debug"

	// TCPResponseRuleLogLevelSilent captures enum value "silent"
	TCPResponseRuleLogLevelSilent string = "silent"
)
View Source 
const (

	// TCPResponseRuleTypeContent captures enum value "content"
	TCPResponseRuleTypeContent string = "content"

	// TCPResponseRuleTypeInspectDashDelay captures enum value "inspect-delay"
	TCPResponseRuleTypeInspectDashDelay string = "inspect-delay"
)
View Source 
const (

	// TransactionStatusFailed captures enum value "failed"
	TransactionStatusFailed string = "failed"

	// TransactionStatusOutdated captures enum value "outdated"
	TransactionStatusOutdated string = "outdated"

	// TransactionStatusInProgress captures enum value "in_progress"
	TransactionStatusInProgress string = "in_progress"

	// TransactionStatusSuccess captures enum value "success"
	TransactionStatusSuccess string = "success"
)
View Source 
const (

	// DefaultsContstatsEnabled captures enum value "enabled"
	DefaultsContstatsEnabled string = "enabled"
)
View Source 
const (

	// ForwardforEnabledEnabled captures enum value "enabled"
	ForwardforEnabledEnabled string = "enabled"
)
View Source 
const (

	// FrontendContstatsEnabled captures enum value "enabled"
	FrontendContstatsEnabled string = "enabled"
)
View Source 
const (

	// HTTPErrorRuleTypeStatus captures enum value "status"
	HTTPErrorRuleTypeStatus string = "status"
)
View Source 
const (

	// HashTypeModifierAvalanche captures enum value "avalanche"
	HashTypeModifierAvalanche string = "avalanche"
)
View Source 
const (

	// OriginaltoEnabledEnabled captures enum value "enabled"
	OriginaltoEnabledEnabled string = "enabled"
)
View Source 
const (

	// PersistRuleTypeRdpDashCookie captures enum value "rdp-cookie"
	PersistRuleTypeRdpDashCookie string = "rdp-cookie"
)
View Source 
const (

	// RuntimeAddServerOnMarkedDownShutdownDashSessions captures enum value "shutdown-sessions"
	RuntimeAddServerOnMarkedDownShutdownDashSessions string = "shutdown-sessions"
)
View Source 
const (

	// RuntimeAddServerOnMarkedUpShutdownDashBackupDashSessions captures enum value "shutdown-backup-sessions"
	RuntimeAddServerOnMarkedUpShutdownDashBackupDashSessions string = "shutdown-backup-sessions"
)
View Source 
const (

	// ServerParamsOnMarkedDownShutdownDashSessions captures enum value "shutdown-sessions"
	ServerParamsOnMarkedDownShutdownDashSessions string = "shutdown-sessions"
)
View Source 
const (

	// ServerParamsOnMarkedUpShutdownDashBackupDashSessions captures enum value "shutdown-backup-sessions"
	ServerParamsOnMarkedUpShutdownDashBackupDashSessions string = "shutdown-backup-sessions"
)
View Source 
const (

	// SpoeAgentContinueOnErrorEnabled captures enum value "enabled"
	SpoeAgentContinueOnErrorEnabled string = "enabled"
)
View Source 
const (

	// SpoeAgentForceSetVarEnabled captures enum value "enabled"
	SpoeAgentForceSetVarEnabled string = "enabled"
)

Variables ¶

View Source 
var NilSameAsEmpty = true
View Source 
var SkipIndex = true

Functions ¶

func CheckSameNilAndLen ¶ added in v5.1.0 

func CheckSameNilAndLen[T any](s, t []T, opts ...Options) bool

func Ptr ¶ added in v5.1.0 

func Ptr[V any](v V) *V

func ValueOrNil ¶ added in v5.1.0 

func ValueOrNil[T any](v *T) any

Types ¶

type ACL ¶ 

type ACL struct {
	// acl name
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ACLName string `json:"acl_name"`

	// criterion
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Criterion string `json:"criterion"`

	// index
	// Required: true
	// +kubebuilder:validation:Optional
	Index *int64 `json:"index"`

	// value
	Value string `json:"value,omitempty"`
}

ACL ACL Lines

The use of Access Control Lists (ACL) provides a flexible solution to perform content switching and generally to take decisions based on content extracted from the request, the response or any environmental status.

swagger:model acl

func (*ACL) ContextValidate ¶ 

func (m *ACL) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this acl based on context it is used

func (ACL) Diff ¶ added in v5.1.0 

func (s ACL) Diff(t ACL, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ACL are equal

By default empty maps and slices are equal to nil: 

var a, b ACL
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ACL
diff := a.Diff(b,Options{
	SkipIndex: true,
})

func (ACL) Equal ¶ added in v5.1.0 

func (s ACL) Equal(t ACL, opts ...Options) bool

Equal checks if two structs of type ACL are equal

By default empty maps and slices are equal to nil: 

var a, b ACL
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ACL
equal := a.Equal(b,Options{
	SkipIndex: true,
})

func (*ACL) MarshalBinary ¶ 

func (m *ACL) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ACL) UnmarshalBinary ¶ 

func (m *ACL) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ACL) Validate ¶ 

func (m *ACL) Validate(formats strfmt.Registry) error

Validate validates this acl

type ACLFile ¶ 

type ACLFile struct {

	// description
	Description string `json:"description,omitempty"`

	// id
	ID string `json:"id,omitempty"`

	// storage name
	StorageName string `json:"storage_name,omitempty"`
}

ACLFile ACL File

ACL File ¶

swagger:model acl_file

func (*ACLFile) ContextValidate ¶ 

func (m *ACLFile) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this acl file based on context it is used

func (ACLFile) Diff ¶ added in v5.1.0 

func (s ACLFile) Diff(t ACLFile, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ACLFile are equal 

var a, b ACLFile
diff := a.Diff(b)

opts ...Options are ignored in this method

func (ACLFile) Equal ¶ added in v5.1.0 

func (s ACLFile) Equal(t ACLFile, opts ...Options) bool

Equal checks if two structs of type ACLFile are equal 

var a, b ACLFile
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*ACLFile) MarshalBinary ¶ 

func (m *ACLFile) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ACLFile) UnmarshalBinary ¶ 

func (m *ACLFile) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ACLFile) Validate ¶ 

func (m *ACLFile) Validate(formats strfmt.Registry) error

Validate validates this acl file

type ACLFileEntry ¶ 

type ACLFileEntry struct {

	// id
	// Read Only: true
	ID string `json:"id,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

ACLFileEntry One ACL File Entry

One ACL File Entry ¶

swagger:model acl_file_entry

func (*ACLFileEntry) ContextValidate ¶ 

func (m *ACLFileEntry) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this acl file entry based on the context it is used

func (ACLFileEntry) Diff ¶ added in v5.1.0 

func (s ACLFileEntry) Diff(t ACLFileEntry, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ACLFileEntry are equal 

var a, b ACLFileEntry
diff := a.Diff(b)

opts ...Options are ignored in this method

func (ACLFileEntry) Equal ¶ added in v5.1.0 

func (s ACLFileEntry) Equal(t ACLFileEntry, opts ...Options) bool

Equal checks if two structs of type ACLFileEntry are equal 

var a, b ACLFileEntry
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*ACLFileEntry) MarshalBinary ¶ 

func (m *ACLFileEntry) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ACLFileEntry) UnmarshalBinary ¶ 

func (m *ACLFileEntry) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ACLFileEntry) Validate ¶ 

func (m *ACLFileEntry) Validate(formats strfmt.Registry) error

Validate validates this acl file entry

type ACLFiles ¶ 

type ACLFiles []*ACLFile

ACLFiles ACL Files Array

Array of runtime acl files ¶

swagger:model acl_files

func (ACLFiles) ContextValidate ¶ 

func (m ACLFiles) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this acl files based on the context it is used

func (ACLFiles) Diff ¶ added in v5.1.0 

func (s ACLFiles) Diff(t ACLFiles, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ACLFiles are equal

By default empty maps and slices are equal to nil: 

var a, b ACLFiles
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ACLFiles
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (ACLFiles) Equal ¶ added in v5.1.0 

func (s ACLFiles) Equal(t ACLFiles, opts ...Options) bool

Equal checks if two structs of type ACLFiles are equal

By default empty maps and slices are equal to nil: 

var a, b ACLFiles
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ACLFiles
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (ACLFiles) Validate ¶ 

func (m ACLFiles) Validate(formats strfmt.Registry) error

Validate validates this acl files

type ACLFilesEntries ¶ 

type ACLFilesEntries []*ACLFileEntry

ACLFilesEntries ACL Files Entries

Array of entries of one runtime acl file ¶

swagger:model acl_files_entries

func (ACLFilesEntries) ContextValidate ¶ 

func (m ACLFilesEntries) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this acl files entries based on the context it is used

func (ACLFilesEntries) Diff ¶ added in v5.1.0 

func (s ACLFilesEntries) Diff(t ACLFilesEntries, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ACLFilesEntries are equal

By default empty maps and slices are equal to nil: 

var a, b ACLFilesEntries
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ACLFilesEntries
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (ACLFilesEntries) Equal ¶ added in v5.1.0 

func (s ACLFilesEntries) Equal(t ACLFilesEntries, opts ...Options) bool

Equal checks if two structs of type ACLFilesEntries are equal

By default empty maps and slices are equal to nil: 

var a, b ACLFilesEntries
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ACLFilesEntries
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (ACLFilesEntries) Validate ¶ 

func (m ACLFilesEntries) Validate(formats strfmt.Registry) error

Validate validates this acl files entries

type Acls ¶ 

type Acls []*ACL

Acls ACL Lines Array

HAProxy ACL lines array (corresponds to acl directives)

swagger:model acls

func (Acls) ContextValidate ¶ 

func (m Acls) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this acls based on the context it is used

func (Acls) Diff ¶ added in v5.1.0 

func (s Acls) Diff(t Acls, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Acls are equal

By default empty maps and slices are equal to nil: 

var a, b Acls
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Acls
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Acls) Equal ¶ added in v5.1.0 

func (s Acls) Equal(t Acls, opts ...Options) bool

Equal checks if two structs of type Acls are equal

By default empty maps and slices are equal to nil: 

var a, b Acls
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Acls
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Acls) Validate ¶ 

func (m Acls) Validate(formats strfmt.Registry) error

Validate validates this acls

type Attr ¶ 

type Attr struct {
	// value
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Value string `json:"value,omitempty"`
}

Attr attr

swagger:model Attr

func (*Attr) ContextValidate ¶ 

func (m *Attr) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this attr based on context it is used

func (Attr) Diff ¶ added in v5.1.0 

func (s Attr) Diff(t Attr, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Attr are equal 

var a, b Attr
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Attr) Equal ¶ added in v5.1.0 

func (s Attr) Equal(t Attr, opts ...Options) bool

Equal checks if two structs of type Attr are equal 

var a, b Attr
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Attr) MarshalBinary ¶ 

func (m *Attr) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Attr) UnmarshalBinary ¶ 

func (m *Attr) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Attr) Validate ¶ 

func (m *Attr) Validate(formats strfmt.Registry) error

Validate validates this attr

type AwsFilters ¶ 

type AwsFilters struct {

	// Key to use as filter, using the format specified at https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html#options
	// Required: true
	Key *string `json:"key"`

	// Value of the filter to use
	// Required: true
	Value *string `json:"value"`
}

AwsFilters aws filters

swagger:model awsFilters

func (*AwsFilters) ContextValidate ¶ 

func (m *AwsFilters) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this aws filters based on context it is used

func (AwsFilters) Diff ¶ added in v5.1.0 

func (s AwsFilters) Diff(t AwsFilters, opts ...Options) map[string][]interface{}

Diff checks if two structs of type AwsFilters are equal 

var a, b AwsFilters
diff := a.Diff(b)

opts ...Options are ignored in this method

func (AwsFilters) Equal ¶ added in v5.1.0 

func (s AwsFilters) Equal(t AwsFilters, opts ...Options) bool

Equal checks if two structs of type AwsFilters are equal 

var a, b AwsFilters
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*AwsFilters) MarshalBinary ¶ 

func (m *AwsFilters) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*AwsFilters) UnmarshalBinary ¶ 

func (m *AwsFilters) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*AwsFilters) Validate ¶ 

func (m *AwsFilters) Validate(formats strfmt.Registry) error

Validate validates this aws filters

type AwsRegion ¶ 

type AwsRegion struct {

	// AWS Access Key ID.
	AccessKeyID string `json:"access_key_id,omitempty"`

	// Specify the AWS filters used to filter the EC2 instances to add
	Allowlist []*AwsFilters `json:"allowlist,omitempty"`

	// Specify the AWS filters used to filter the EC2 instances to ignore
	Denylist []*AwsFilters `json:"denylist,omitempty"`

	// description
	Description string `json:"description,omitempty"`

	// enabled
	// Required: true
	Enabled *bool `json:"enabled"`

	// Auto generated ID.
	// Read Only: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ID *string `json:"id,omitempty"`

	// Select which IPv4 address the Service Discovery has to use for the backend server entry
	// Required: true
	// Enum: [private public]
	// +kubebuilder:validation:Enum=private;public;
	IPV4Address *string `json:"ipv4_address"`

	// name
	// Required: true
	Name *string `json:"name"`

	// region
	// Required: true
	Region *string `json:"region"`

	// Duration in seconds in-between data pulling requests to the AWS region
	// Required: true
	// Minimum: 1
	// +kubebuilder:validation:Minimum=1
	RetryTimeout *int64 `json:"retry_timeout"`

	// AWS Secret Access Key.
	SecretAccessKey string `json:"secret_access_key,omitempty"`

	// server slots base
	ServerSlotsBase *int64 `json:"server_slots_base,omitempty"`

	// server slots growth increment
	ServerSlotsGrowthIncrement int64 `json:"server_slots_growth_increment,omitempty"`

	// server slots growth type
	// Enum: [linear exponential]
	// +kubebuilder:validation:Enum=linear;exponential;
	ServerSlotsGrowthType *string `json:"server_slots_growth_type,omitempty"`
}

AwsRegion AWS region

AWS region configuration Example: {"access_key_id":"****************L7GT","allowlist":[{"key":"tag-key","value":"Instance:Having:This:Tag"}],"denylist":[{"key":"tag:Environment","value":"development"}],"enabled":true,"id":"0","ipv4_address":"private","name":"frontend-service","region":"us-east-1","retry_timeout":1,"secret_access_key":"****************soLl"}

swagger:model awsRegion

func (*AwsRegion) ContextValidate ¶ 

func (m *AwsRegion) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this aws region based on the context it is used

func (AwsRegion) Diff ¶ added in v5.1.0 

func (s AwsRegion) Diff(t AwsRegion, opts ...Options) map[string][]interface{}

Diff checks if two structs of type AwsRegion are equal

By default empty maps and slices are equal to nil: 

var a, b AwsRegion
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b AwsRegion
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (AwsRegion) Equal ¶ added in v5.1.0 

func (s AwsRegion) Equal(t AwsRegion, opts ...Options) bool

Equal checks if two structs of type AwsRegion are equal

By default empty maps and slices are equal to nil: 

var a, b AwsRegion
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b AwsRegion
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*AwsRegion) MarshalBinary ¶ 

func (m *AwsRegion) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*AwsRegion) UnmarshalBinary ¶ 

func (m *AwsRegion) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*AwsRegion) Validate ¶ 

func (m *AwsRegion) Validate(formats strfmt.Registry) error

Validate validates this aws region

type AwsRegions ¶ 

type AwsRegions []*AwsRegion

AwsRegions AWS

AWS regions array ¶

swagger:model awsRegions

func (AwsRegions) ContextValidate ¶ 

func (m AwsRegions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this aws regions based on the context it is used

func (AwsRegions) Diff ¶ added in v5.1.0 

func (s AwsRegions) Diff(t AwsRegions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type AwsRegions are equal

By default empty maps and slices are equal to nil: 

var a, b AwsRegions
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b AwsRegions
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (AwsRegions) Equal ¶ added in v5.1.0 

func (s AwsRegions) Equal(t AwsRegions, opts ...Options) bool

Equal checks if two structs of type AwsRegions are equal

By default empty maps and slices are equal to nil: 

var a, b AwsRegions
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b AwsRegions
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (AwsRegions) Validate ¶ 

func (m AwsRegions) Validate(formats strfmt.Registry) error

Validate validates this aws regions

type Backend ¶ 

type Backend struct {

	// error files
	ErrorFiles []*Errorfile `json:"error_files,omitempty"`

	// error files from HTTP errors
	ErrorFilesFromHTTPErrors []*Errorfiles `json:"errorfiles_from_http_errors,omitempty"`

	// force persist list
	ForcePersistList []*ForcePersist `json:"force_persist_list,omitempty"`

	// ignore persist list
	IgnorePersistList []*IgnorePersist `json:"ignore_persist_list,omitempty"`

	// abortonclose
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Abortonclose string `json:"abortonclose,omitempty"`

	// accept invalid http response
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	AcceptInvalidHTTPResponse string `json:"accept_invalid_http_response,omitempty"`

	// adv check
	// Enum: [httpchk ldap-check mysql-check pgsql-check redis-check smtpchk ssl-hello-chk tcp-check]
	// +kubebuilder:validation:Enum=httpchk;ldap-check;mysql-check;pgsql-check;redis-check;smtpchk;ssl-hello-chk;tcp-check;
	AdvCheck string `json:"adv_check,omitempty"`

	// allbackups
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Allbackups string `json:"allbackups,omitempty"`

	// balance
	Balance *Balance `json:"balance,omitempty"`

	// bind process
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	BindProcess string `json:"bind_process,omitempty"`

	// check timeout
	CheckTimeout *int64 `json:"check_timeout,omitempty"`

	// checkcache
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Checkcache string `json:"checkcache,omitempty"`

	// compression
	Compression *Compression `json:"compression,omitempty"`

	// connect timeout
	ConnectTimeout *int64 `json:"connect_timeout,omitempty"`

	// cookie
	Cookie *Cookie `json:"cookie,omitempty"`

	// default server
	DefaultServer *DefaultServer `json:"default_server,omitempty"`

	// description
	Description string `json:"description,omitempty"`

	// disabled
	Disabled bool `json:"disabled,omitempty"`

	// dynamic cookie key
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	DynamicCookieKey string `json:"dynamic_cookie_key,omitempty"`

	// email alert
	EmailAlert *EmailAlert `json:"email_alert,omitempty"`

	// enabled
	Enabled bool `json:"enabled,omitempty"`

	// errorloc302
	Errorloc302 *Errorloc `json:"errorloc302,omitempty"`

	// errorloc303
	Errorloc303 *Errorloc `json:"errorloc303,omitempty"`

	// external check
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	ExternalCheck string `json:"external_check,omitempty"`

	// external check command
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ExternalCheckCommand string `json:"external_check_command,omitempty"`

	// external check path
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ExternalCheckPath string `json:"external_check_path,omitempty"`

	// force persist
	ForcePersist *BackendForcePersist `json:"force_persist,omitempty"`

	// forwardfor
	Forwardfor *Forwardfor `json:"forwardfor,omitempty"`

	// from
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	From string `json:"from,omitempty"`

	// fullconn
	Fullconn *int64 `json:"fullconn,omitempty"`

	// h1 case adjust bogus server
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	H1CaseAdjustBogusServer string `json:"h1_case_adjust_bogus_server,omitempty"`

	// hash balance factor
	HashBalanceFactor *int64 `json:"hash_balance_factor,omitempty"`

	// hash type
	HashType *HashType `json:"hash_type,omitempty"`

	// http buffer request
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPBufferRequest string `json:"http-buffer-request,omitempty"`

	// http check
	HTTPCheck *HTTPCheck `json:"http-check,omitempty"`

	// http keep alive
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPKeepAlive string `json:"http-keep-alive,omitempty"`

	// http no delay
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPNoDelay string `json:"http-no-delay,omitempty"`

	// http server close
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPServerClose string `json:"http-server-close,omitempty"`

	// http use htx
	// Pattern: ^[^\s]+$
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPUseHtx string `json:"http-use-htx,omitempty"`

	// http connection mode
	// Enum: [httpclose http-server-close http-keep-alive]
	// +kubebuilder:validation:Enum=httpclose;http-server-close;http-keep-alive;
	HTTPConnectionMode string `json:"http_connection_mode,omitempty"`

	// http keep alive timeout
	HTTPKeepAliveTimeout *int64 `json:"http_keep_alive_timeout,omitempty"`

	// http pretend keepalive
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPPretendKeepalive string `json:"http_pretend_keepalive,omitempty"`

	// http proxy
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPProxy string `json:"http_proxy,omitempty"`

	// http request timeout
	HTTPRequestTimeout *int64 `json:"http_request_timeout,omitempty"`

	// http restrict req hdr names
	// Enum: [preserve delete reject]
	// +kubebuilder:validation:Enum=preserve;delete;reject;
	HTTPRestrictReqHdrNames string `json:"http_restrict_req_hdr_names,omitempty"`

	// http reuse
	// Enum: [aggressive always never safe]
	// +kubebuilder:validation:Enum=aggressive;always;never;safe;
	HTTPReuse string `json:"http_reuse,omitempty"`

	// http send name header
	HTTPSendNameHeader *string `json:"http_send_name_header,omitempty"`

	// httpchk params
	HttpchkParams *HttpchkParams `json:"httpchk_params,omitempty"`

	// httpclose
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Httpclose string `json:"httpclose,omitempty"`

	// id
	ID *int64 `json:"id,omitempty"`

	// ignore persist
	IgnorePersist *BackendIgnorePersist `json:"ignore_persist,omitempty"`

	// independent streams
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	IndependentStreams string `json:"independent_streams,omitempty"`

	// load server state from file
	// Enum: [global local none]
	// +kubebuilder:validation:Enum=global;local;none;
	LoadServerStateFromFile string `json:"load_server_state_from_file,omitempty"`

	// log health checks
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	LogHealthChecks string `json:"log_health_checks,omitempty"`

	// log tag
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	LogTag string `json:"log_tag,omitempty"`

	// max keep alive queue
	MaxKeepAliveQueue *int64 `json:"max_keep_alive_queue,omitempty"`

	// mode
	// Enum: [http tcp log]
	// +kubebuilder:validation:Enum=http;tcp;log;
	Mode string `json:"mode,omitempty"`

	// mysql check params
	MysqlCheckParams *MysqlCheckParams `json:"mysql_check_params,omitempty"`

	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name string `json:"name"`

	// nolinger
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Nolinger string `json:"nolinger,omitempty"`

	// originalto
	Originalto *Originalto `json:"originalto,omitempty"`

	// persist
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Persist string `json:"persist,omitempty"`

	// persist rule
	PersistRule *PersistRule `json:"persist_rule,omitempty"`

	// pgsql check params
	PgsqlCheckParams *PgsqlCheckParams `json:"pgsql_check_params,omitempty"`

	// prefer last server
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	PreferLastServer string `json:"prefer_last_server,omitempty"`

	// queue timeout
	QueueTimeout *int64 `json:"queue_timeout,omitempty"`

	// redispatch
	Redispatch *Redispatch `json:"redispatch,omitempty"`

	// retries
	Retries *int64 `json:"retries,omitempty"`

	// retry on
	RetryOn string `json:"retry_on,omitempty"`

	// server fin timeout
	ServerFinTimeout *int64 `json:"server_fin_timeout,omitempty"`

	// server state file name
	ServerStateFileName string `json:"server_state_file_name,omitempty"`

	// server timeout
	ServerTimeout *int64 `json:"server_timeout,omitempty"`

	// smtpchk params
	SmtpchkParams *SmtpchkParams `json:"smtpchk_params,omitempty"`

	// source
	Source *Source `json:"source,omitempty"`

	// splice auto
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SpliceAuto string `json:"splice_auto,omitempty"`

	// splice request
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SpliceRequest string `json:"splice_request,omitempty"`

	// splice response
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SpliceResponse string `json:"splice_response,omitempty"`

	// spop check
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SpopCheck string `json:"spop_check,omitempty"`

	// srvtcpka
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Srvtcpka string `json:"srvtcpka,omitempty"`

	// srvtcpka cnt
	SrvtcpkaCnt *int64 `json:"srvtcpka_cnt,omitempty"`

	// srvtcpka idle
	SrvtcpkaIdle *int64 `json:"srvtcpka_idle,omitempty"`

	// srvtcpka intvl
	SrvtcpkaIntvl *int64 `json:"srvtcpka_intvl,omitempty"`

	// stats options
	StatsOptions *StatsOptions `json:"stats_options,omitempty"`

	// stick table
	StickTable *ConfigStickTable `json:"stick_table,omitempty"`

	// tarpit timeout
	TarpitTimeout *int64 `json:"tarpit_timeout,omitempty"`

	// tcp smart connect
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	TCPSmartConnect string `json:"tcp_smart_connect,omitempty"`

	// tcpka
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Tcpka string `json:"tcpka,omitempty"`

	// transparent
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Transparent string `json:"transparent,omitempty"`

	// tunnel timeout
	TunnelTimeout *int64 `json:"tunnel_timeout,omitempty"`

	// use fcgi app
	UseFCGIApp string `json:"use_fcgi_app,omitempty"`
}

Backend Backend

HAProxy backend configuration Example: {"adv_check":"httpchk","balance":{"algorithm":"roundrobin"},"forwardfor":{"enabled":"enabled"},"httpchk_params":{"method":"GET","uri":"/check","version":"HTTP/1.1"},"mode":"http","name":"test_backend"}

swagger:model backend

func (*Backend) ContextValidate ¶ 

func (m *Backend) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this backend based on the context it is used

func (Backend) Diff ¶ added in v5.1.0 

func (s Backend) Diff(t Backend, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Backend are equal

By default empty maps and slices are equal to nil: 

var a, b Backend
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Backend
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Backend) Equal ¶ added in v5.1.0 

func (s Backend) Equal(t Backend, opts ...Options) bool

Equal checks if two structs of type Backend are equal

By default empty maps and slices are equal to nil: 

var a, b Backend
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Backend
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Backend) MarshalBinary ¶ 

func (m *Backend) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Backend) UnmarshalBinary ¶ 

func (m *Backend) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Backend) Validate ¶ 

func (m *Backend) Validate(formats strfmt.Registry) error

Validate validates this backend

type BackendForcePersist ¶ 

type BackendForcePersist struct {
	// cond
	// Required: true
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond *string `json:"cond"`

	// cond test
	// Required: true
	CondTest *string `json:"cond_test"`
}

BackendForcePersist This field is deprecated in favor of force_persist_list, and will be removed in a future release

swagger:model BackendForcePersist

func (*BackendForcePersist) ContextValidate ¶ 

func (m *BackendForcePersist) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this backend force persist based on context it is used

func (BackendForcePersist) Diff ¶ added in v5.1.0 

func (s BackendForcePersist) Diff(t BackendForcePersist, opts ...Options) map[string][]interface{}

Diff checks if two structs of type BackendForcePersist are equal 

var a, b BackendForcePersist
diff := a.Diff(b)

opts ...Options are ignored in this method

func (BackendForcePersist) Equal ¶ added in v5.1.0 

func (s BackendForcePersist) Equal(t BackendForcePersist, opts ...Options) bool

Equal checks if two structs of type BackendForcePersist are equal 

var a, b BackendForcePersist
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*BackendForcePersist) MarshalBinary ¶ 

func (m *BackendForcePersist) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*BackendForcePersist) UnmarshalBinary ¶ 

func (m *BackendForcePersist) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*BackendForcePersist) Validate ¶ 

func (m *BackendForcePersist) Validate(formats strfmt.Registry) error

Validate validates this backend force persist

type BackendIgnorePersist ¶ 

type BackendIgnorePersist struct {
	// cond
	// Required: true
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond *string `json:"cond"`

	// cond test
	// Required: true
	CondTest *string `json:"cond_test"`
}

BackendIgnorePersist This field is deprecated in favor of ignore_persist_list, and will be removed in a future release

swagger:model BackendIgnorePersist

func (*BackendIgnorePersist) ContextValidate ¶ 

func (m *BackendIgnorePersist) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this backend ignore persist based on context it is used

func (BackendIgnorePersist) Diff ¶ added in v5.1.0 

func (s BackendIgnorePersist) Diff(t BackendIgnorePersist, opts ...Options) map[string][]interface{}

Diff checks if two structs of type BackendIgnorePersist are equal 

var a, b BackendIgnorePersist
diff := a.Diff(b)

opts ...Options are ignored in this method

func (BackendIgnorePersist) Equal ¶ added in v5.1.0 

func (s BackendIgnorePersist) Equal(t BackendIgnorePersist, opts ...Options) bool

Equal checks if two structs of type BackendIgnorePersist are equal 

var a, b BackendIgnorePersist
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*BackendIgnorePersist) MarshalBinary ¶ 

func (m *BackendIgnorePersist) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*BackendIgnorePersist) UnmarshalBinary ¶ 

func (m *BackendIgnorePersist) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*BackendIgnorePersist) Validate ¶ 

func (m *BackendIgnorePersist) Validate(formats strfmt.Registry) error

Validate validates this backend ignore persist

type BackendSwitchingRule ¶ 

type BackendSwitchingRule struct {
	// cond
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond string `json:"cond,omitempty"`

	// cond test
	CondTest string `json:"cond_test,omitempty"`

	// index
	// Required: true
	// +kubebuilder:validation:Optional
	Index *int64 `json:"index"`

	// name
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Name string `json:"name"`
}

BackendSwitchingRule Backend Switching Rule

HAProxy backend switching rule configuration (corresponds to use_backend directive) Example: {"cond":"if","cond_test":"{ req_ssl_sni -i www.example.com }","index":0,"name":"test_backend"}

swagger:model backend_switching_rule

func (*BackendSwitchingRule) ContextValidate ¶ 

func (m *BackendSwitchingRule) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this backend switching rule based on context it is used

func (BackendSwitchingRule) Diff ¶ added in v5.1.0 

func (s BackendSwitchingRule) Diff(t BackendSwitchingRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type BackendSwitchingRule are equal

By default empty maps and slices are equal to nil: 

var a, b BackendSwitchingRule
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b BackendSwitchingRule
diff := a.Diff(b,Options{
	SkipIndex: true,
})

func (BackendSwitchingRule) Equal ¶ added in v5.1.0 

func (s BackendSwitchingRule) Equal(t BackendSwitchingRule, opts ...Options) bool

Equal checks if two structs of type BackendSwitchingRule are equal

By default empty maps and slices are equal to nil: 

var a, b BackendSwitchingRule
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b BackendSwitchingRule
equal := a.Equal(b,Options{
	SkipIndex: true,
})

func (*BackendSwitchingRule) MarshalBinary ¶ 

func (m *BackendSwitchingRule) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*BackendSwitchingRule) UnmarshalBinary ¶ 

func (m *BackendSwitchingRule) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*BackendSwitchingRule) Validate ¶ 

func (m *BackendSwitchingRule) Validate(formats strfmt.Registry) error

Validate validates this backend switching rule

type BackendSwitchingRules ¶ 

type BackendSwitchingRules []*BackendSwitchingRule

BackendSwitchingRules Backend Switching Rules Array

HAProxy backend switching rules array (corresponds to use_backend directives)

swagger:model backend_switching_rules

func (BackendSwitchingRules) ContextValidate ¶ 

func (m BackendSwitchingRules) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this backend switching rules based on the context it is used

func (BackendSwitchingRules) Diff ¶ added in v5.1.0 

func (s BackendSwitchingRules) Diff(t BackendSwitchingRules, opts ...Options) map[string][]interface{}

Diff checks if two structs of type BackendSwitchingRules are equal

By default empty maps and slices are equal to nil: 

var a, b BackendSwitchingRules
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b BackendSwitchingRules
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (BackendSwitchingRules) Equal ¶ added in v5.1.0 

func (s BackendSwitchingRules) Equal(t BackendSwitchingRules, opts ...Options) bool

Equal checks if two structs of type BackendSwitchingRules are equal

By default empty maps and slices are equal to nil: 

var a, b BackendSwitchingRules
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b BackendSwitchingRules
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (BackendSwitchingRules) Validate ¶ 

func (m BackendSwitchingRules) Validate(formats strfmt.Registry) error

Validate validates this backend switching rules

type Backends ¶ 

type Backends []*Backend

Backends Backends

HAProxy backends array ¶

swagger:model backends

func (Backends) ContextValidate ¶ 

func (m Backends) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this backends based on the context it is used

func (Backends) Diff ¶ added in v5.1.0 

func (s Backends) Diff(t Backends, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Backends are equal

By default empty maps and slices are equal to nil: 

var a, b Backends
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Backends
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Backends) Equal ¶ added in v5.1.0 

func (s Backends) Equal(t Backends, opts ...Options) bool

Equal checks if two structs of type Backends are equal

By default empty maps and slices are equal to nil: 

var a, b Backends
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Backends
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Backends) Validate ¶ 

func (m Backends) Validate(formats strfmt.Registry) error

Validate validates this backends

type Balance ¶ 

type Balance struct {
	// algorithm
	// Required: true
	// Enum: [first hash hdr leastconn random rdp-cookie roundrobin source static-rr uri url_param]
	// +kubebuilder:validation:Enum=first;hash;hdr;leastconn;random;rdp-cookie;roundrobin;source;static-rr;uri;url_param;
	Algorithm *string `json:"algorithm"`

	// hash expression
	HashExpression string `json:"hash_expression,omitempty"`

	// hdr name
	HdrName string `json:"hdr_name,omitempty"`

	// hdr use domain only
	HdrUseDomainOnly bool `json:"hdr_use_domain_only,omitempty"`

	// random draws
	RandomDraws int64 `json:"random_draws,omitempty"`

	// rdp cookie name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	RdpCookieName string `json:"rdp_cookie_name,omitempty"`

	// uri depth
	URIDepth int64 `json:"uri_depth,omitempty"`

	// uri len
	URILen int64 `json:"uri_len,omitempty"`

	// uri path only
	URIPathOnly bool `json:"uri_path_only,omitempty"`

	// uri whole
	URIWhole bool `json:"uri_whole,omitempty"`

	// url param
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	URLParam string `json:"url_param,omitempty"`

	// url param check post
	URLParamCheckPost int64 `json:"url_param_check_post,omitempty"`

	// url param max wait
	URLParamMaxWait int64 `json:"url_param_max_wait,omitempty"`
}

Balance balance

swagger:model balance

func (*Balance) ContextValidate ¶ 

func (m *Balance) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this balance based on context it is used

func (Balance) Diff ¶ added in v5.1.0 

func (s Balance) Diff(t Balance, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Balance are equal 

var a, b Balance
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Balance) Equal ¶ added in v5.1.0 

func (s Balance) Equal(t Balance, opts ...Options) bool

Equal checks if two structs of type Balance are equal 

var a, b Balance
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Balance) MarshalBinary ¶ 

func (m *Balance) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Balance) UnmarshalBinary ¶ 

func (m *Balance) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Balance) Validate ¶ 

func (m *Balance) Validate(formats strfmt.Registry) error

Validate validates this balance

type Bind ¶ 

type Bind struct {
	BindParams `json:",inline"`

	// address
	// Example: 127.0.0.1
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Address string `json:"address,omitempty"`

	// port
	// Example: 80
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port *int64 `json:"port,omitempty"`

	// port range end
	// Example: 81
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	PortRangeEnd *int64 `json:"port-range-end,omitempty"`
}

Bind Bind

HAProxy frontend bind configuration ¶

swagger:model bind

func (*Bind) ContextValidate ¶ 

func (m *Bind) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this bind based on the context it is used

func (Bind) Diff ¶ added in v5.1.0 

func (s Bind) Diff(t Bind, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Bind are equal

By default empty maps and slices are equal to nil: 

var a, b Bind
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Bind
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Bind) Equal ¶ added in v5.1.0 

func (s Bind) Equal(t Bind, opts ...Options) bool

Equal checks if two structs of type Bind are equal

By default empty maps and slices are equal to nil: 

var a, b Bind
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Bind
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Bind) MarshalBinary ¶ 

func (m *Bind) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Bind) MarshalJSON ¶ 

func (m Bind) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*Bind) UnmarshalBinary ¶ 

func (m *Bind) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Bind) UnmarshalJSON ¶ 

func (m *Bind) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*Bind) Validate ¶ 

func (m *Bind) Validate(formats strfmt.Registry) error

Validate validates this bind

type BindParams ¶ 

type BindParams struct {

	// accept netscaler cip
	AcceptNetscalerCip int64 `json:"accept_netscaler_cip,omitempty"`

	// accept proxy
	AcceptProxy bool `json:"accept_proxy,omitempty"`

	// allow 0rtt
	Allow0rtt bool `json:"allow_0rtt,omitempty"`

	// alpn
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Alpn string `json:"alpn,omitempty"`

	// backlog
	Backlog string `json:"backlog,omitempty"`

	// ca ignore err
	CaIgnoreErr string `json:"ca_ignore_err,omitempty"`

	// ca sign file
	CaSignFile string `json:"ca_sign_file,omitempty"`

	// ca sign pass
	CaSignPass string `json:"ca_sign_pass,omitempty"`

	// ca verify file
	CaVerifyFile string `json:"ca_verify_file,omitempty"`

	// ciphers
	Ciphers string `json:"ciphers,omitempty"`

	// ciphersuites
	Ciphersuites string `json:"ciphersuites,omitempty"`

	// client sigalgs
	ClientSigalgs string `json:"client_sigalgs,omitempty"`

	// crl file
	CrlFile string `json:"crl_file,omitempty"`

	// crt ignore err
	CrtIgnoreErr string `json:"crt_ignore_err,omitempty"`

	// crt list
	CrtList string `json:"crt_list,omitempty"`

	// curves
	Curves string `json:"curves,omitempty"`

	// defer accept
	DeferAccept bool `json:"defer_accept,omitempty"`

	// ecdhe
	Ecdhe string `json:"ecdhe,omitempty"`

	// expose fd listeners
	ExposeFdListeners bool `json:"expose_fd_listeners,omitempty"`

	// force sslv3
	ForceSslv3 bool `json:"force_sslv3,omitempty"`

	// force tlsv10
	ForceTlsv10 bool `json:"force_tlsv10,omitempty"`

	// force tlsv11
	ForceTlsv11 bool `json:"force_tlsv11,omitempty"`

	// force tlsv12
	ForceTlsv12 bool `json:"force_tlsv12,omitempty"`

	// force tlsv13
	ForceTlsv13 bool `json:"force_tlsv13,omitempty"`

	// generate certificates
	GenerateCertificates bool `json:"generate_certificates,omitempty"`

	// gid
	Gid int64 `json:"gid,omitempty"`

	// group
	Group string `json:"group,omitempty"`

	// id
	ID string `json:"id,omitempty"`

	// interface
	Interface string `json:"interface,omitempty"`

	// level
	// Example: user
	// Enum: [user operator admin]
	// +kubebuilder:validation:Enum=user;operator;admin;
	Level string `json:"level,omitempty"`

	// maxconn
	// Example: 1234
	Maxconn int64 `json:"maxconn,omitempty"`

	// mode
	Mode string `json:"mode,omitempty"`

	// mss
	Mss string `json:"mss,omitempty"`

	// name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Name string `json:"name,omitempty"`

	// namespace
	// Example: app
	Namespace string `json:"namespace,omitempty"`

	// nbconn
	Nbconn int64 `json:"nbconn,omitempty"`

	// nice
	// Example: 1
	Nice int64 `json:"nice,omitempty"`

	// no alpn
	NoAlpn bool `json:"no_alpn,omitempty"`

	// no ca names
	NoCaNames bool `json:"no_ca_names,omitempty"`

	// no sslv3
	NoSslv3 bool `json:"no_sslv3,omitempty"`

	// no tls tickets
	NoTLSTickets bool `json:"no_tls_tickets,omitempty"`

	// no tlsv10
	NoTlsv10 bool `json:"no_tlsv10,omitempty"`

	// no tlsv11
	NoTlsv11 bool `json:"no_tlsv11,omitempty"`

	// no tlsv12
	NoTlsv12 bool `json:"no_tlsv12,omitempty"`

	// no tlsv13
	NoTlsv13 bool `json:"no_tlsv13,omitempty"`

	// npn
	Npn string `json:"npn,omitempty"`

	// prefer client ciphers
	PreferClientCiphers bool `json:"prefer_client_ciphers,omitempty"`

	// process
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Process string `json:"process,omitempty"`

	// proto
	Proto string `json:"proto,omitempty"`

	// quic cc algo
	// Enum: [cubic newreno]
	// +kubebuilder:validation:Enum=cubic;newreno;
	QuicCcAlgo string `json:"quic-cc-algo,omitempty"`

	// quic force retry
	QuicForceRetry bool `json:"quic-force-retry,omitempty"`

	// quic socket
	// Enum: [connection listener]
	// +kubebuilder:validation:Enum=connection;listener;
	QuicSocket string `json:"quic-socket,omitempty"`

	// severity output
	// Example: none
	// Enum: [none number string]
	// +kubebuilder:validation:Enum=none;number;string;
	SeverityOutput string `json:"severity_output,omitempty"`

	// sigalgs
	Sigalgs string `json:"sigalgs,omitempty"`

	// ssl
	Ssl bool `json:"ssl,omitempty"`

	// ssl cafile
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	SslCafile string `json:"ssl_cafile,omitempty"`

	// ssl certificate
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	SslCertificate string `json:"ssl_certificate,omitempty"`

	// ssl max ver
	// Enum: [SSLv3 TLSv1.0 TLSv1.1 TLSv1.2 TLSv1.3]
	// +kubebuilder:validation:Enum=SSLv3;TLSv1.0;TLSv1.1;TLSv1.2;TLSv1.3;
	SslMaxVer string `json:"ssl_max_ver,omitempty"`

	// ssl min ver
	// Enum: [SSLv3 TLSv1.0 TLSv1.1 TLSv1.2 TLSv1.3]
	// +kubebuilder:validation:Enum=SSLv3;TLSv1.0;TLSv1.1;TLSv1.2;TLSv1.3;
	SslMinVer string `json:"ssl_min_ver,omitempty"`

	// strict sni
	StrictSni bool `json:"strict_sni,omitempty"`

	// tcp user timeout
	TCPUserTimeout *int64 `json:"tcp_user_timeout,omitempty"`

	// tfo
	Tfo bool `json:"tfo,omitempty"`

	// thread
	Thread string `json:"thread,omitempty"`

	// tls ticket keys
	TLSTicketKeys string `json:"tls_ticket_keys,omitempty"`

	// transparent
	Transparent bool `json:"transparent,omitempty"`

	// uid
	UID string `json:"uid,omitempty"`

	// user
	User string `json:"user,omitempty"`

	// v4v6
	V4v6 bool `json:"v4v6,omitempty"`

	// v6only
	V6only bool `json:"v6only,omitempty"`

	// verify
	// Example: none
	// Enum: [none optional required]
	// +kubebuilder:validation:Enum=none;optional;required;
	Verify string `json:"verify,omitempty"`
}

BindParams bind params

swagger:model bind_params

func (*BindParams) ContextValidate ¶ 

func (m *BindParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this bind params based on context it is used

func (BindParams) Diff ¶ added in v5.1.0 

func (s BindParams) Diff(t BindParams, opts ...Options) map[string][]interface{}

Diff checks if two structs of type BindParams are equal 

var a, b BindParams
diff := a.Diff(b)

opts ...Options are ignored in this method

func (BindParams) Equal ¶ added in v5.1.0 

func (s BindParams) Equal(t BindParams, opts ...Options) bool

Equal checks if two structs of type BindParams are equal 

var a, b BindParams
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*BindParams) MarshalBinary ¶ 

func (m *BindParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*BindParams) UnmarshalBinary ¶ 

func (m *BindParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*BindParams) Validate ¶ 

func (m *BindParams) Validate(formats strfmt.Registry) error

Validate validates this bind params

type Binds ¶ 

type Binds []*Bind

Binds Binds

HAProxy frontend binds array (corresponds to bind directives)

swagger:model binds

func (Binds) ContextValidate ¶ 

func (m Binds) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this binds based on the context it is used

func (Binds) Diff ¶ added in v5.1.0 

func (s Binds) Diff(t Binds, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Binds are equal

By default empty maps and slices are equal to nil: 

var a, b Binds
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Binds
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Binds) Equal ¶ added in v5.1.0 

func (s Binds) Equal(t Binds, opts ...Options) bool

Equal checks if two structs of type Binds are equal

By default empty maps and slices are equal to nil: 

var a, b Binds
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Binds
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Binds) Validate ¶ 

func (m Binds) Validate(formats strfmt.Registry) error

Validate validates this binds

type CPUMap ¶ 

type CPUMap struct {

	// cpu set
	// Required: true
	CPUSet *string `json:"cpu_set"`

	// process
	// Required: true
	Process *string `json:"process"`
}

CPUMap CPU map

swagger:model CPUMap

func (*CPUMap) ContextValidate ¶ 

func (m *CPUMap) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this CPU map based on context it is used

func (CPUMap) Diff ¶ added in v5.1.0 

func (s CPUMap) Diff(t CPUMap, opts ...Options) map[string][]interface{}

Diff checks if two structs of type CPUMap are equal 

var a, b CPUMap
diff := a.Diff(b)

opts ...Options are ignored in this method

func (CPUMap) Equal ¶ added in v5.1.0 

func (s CPUMap) Equal(t CPUMap, opts ...Options) bool

Equal checks if two structs of type CPUMap are equal 

var a, b CPUMap
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*CPUMap) MarshalBinary ¶ 

func (m *CPUMap) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CPUMap) UnmarshalBinary ¶ 

func (m *CPUMap) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CPUMap) Validate ¶ 

func (m *CPUMap) Validate(formats strfmt.Registry) error

Validate validates this CPU map

type Cache ¶ 

type Cache struct {

	// max age
	MaxAge int64 `json:"max_age,omitempty"`

	// max object size
	MaxObjectSize int64 `json:"max_object_size,omitempty"`

	// max secondary entries
	MaxSecondaryEntries int64 `json:"max_secondary_entries,omitempty"`

	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name *string `json:"name"`

	// process vary
	ProcessVary *bool `json:"process_vary,omitempty"`

	// total max size
	// Maximum: 4095
	// Minimum: 1
	// +kubebuilder:validation:Maximum=4095
	// +kubebuilder:validation:Minimum=1
	TotalMaxSize int64 `json:"total_max_size,omitempty"`
}

Cache Cache

HAPRoxy Cache section ¶

swagger:model cache

func (*Cache) ContextValidate ¶ 

func (m *Cache) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this cache based on context it is used

func (Cache) Diff ¶ added in v5.1.0 

func (s Cache) Diff(t Cache, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Cache are equal 

var a, b Cache
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Cache) Equal ¶ added in v5.1.0 

func (s Cache) Equal(t Cache, opts ...Options) bool

Equal checks if two structs of type Cache are equal 

var a, b Cache
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Cache) MarshalBinary ¶ 

func (m *Cache) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Cache) UnmarshalBinary ¶ 

func (m *Cache) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Cache) Validate ¶ 

func (m *Cache) Validate(formats strfmt.Registry) error

Validate validates this cache

type Caches ¶ 

type Caches []*Cache

Caches Cache Sections

HAProxy caches array ¶

swagger:model caches

func (Caches) ContextValidate ¶ 

func (m Caches) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this caches based on the context it is used

func (Caches) Diff ¶ added in v5.1.0 

func (s Caches) Diff(t Caches, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Caches are equal

By default empty maps and slices are equal to nil: 

var a, b Caches
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Caches
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Caches) Equal ¶ added in v5.1.0 

func (s Caches) Equal(t Caches, opts ...Options) bool

Equal checks if two structs of type Caches are equal

By default empty maps and slices are equal to nil: 

var a, b Caches
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Caches
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Caches) Validate ¶ 

func (m Caches) Validate(formats strfmt.Registry) error

Validate validates this caches

type Capture ¶ 

type Capture struct {
	// index
	// Required: true
	// +kubebuilder:validation:Optional
	Index *int64 `json:"index"`

	// length
	// Required: true
	Length int64 `json:"length"`

	// type
	// Required: true
	// Enum: [request response]
	// +kubebuilder:validation:Enum=request;response;
	Type string `json:"type"`
}

Capture Declare Capture

swagger:model capture

func (*Capture) ContextValidate ¶ 

func (m *Capture) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this capture based on context it is used

func (Capture) Diff ¶ added in v5.1.0 

func (s Capture) Diff(t Capture, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Capture are equal

By default empty maps and slices are equal to nil: 

var a, b Capture
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Capture
diff := a.Diff(b,Options{
	SkipIndex: true,
})

func (Capture) Equal ¶ added in v5.1.0 

func (s Capture) Equal(t Capture, opts ...Options) bool

Equal checks if two structs of type Capture are equal

By default empty maps and slices are equal to nil: 

var a, b Capture
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Capture
equal := a.Equal(b,Options{
	SkipIndex: true,
})

func (*Capture) MarshalBinary ¶ 

func (m *Capture) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Capture) UnmarshalBinary ¶ 

func (m *Capture) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Capture) Validate ¶ 

func (m *Capture) Validate(formats strfmt.Registry) error

Validate validates this capture

type Captures ¶ 

type Captures []*Capture

Captures Declare capture array

swagger:model captures

func (Captures) ContextValidate ¶ 

func (m Captures) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this captures based on the context it is used

func (Captures) Diff ¶ added in v5.1.0 

func (s Captures) Diff(t Captures, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Captures are equal

By default empty maps and slices are equal to nil: 

var a, b Captures
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Captures
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Captures) Equal ¶ added in v5.1.0 

func (s Captures) Equal(t Captures, opts ...Options) bool

Equal checks if two structs of type Captures are equal

By default empty maps and slices are equal to nil: 

var a, b Captures
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Captures
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Captures) Validate ¶ 

func (m Captures) Validate(formats strfmt.Registry) error

Validate validates this captures

type ClusterLogTarget ¶ 

type ClusterLogTarget struct {

	// address
	// Required: true
	Address *string `json:"address"`

	// log format
	LogFormat string `json:"log_format,omitempty"`

	// port
	// Required: true
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port *int64 `json:"port"`

	// protocol
	// Required: true
	// Enum: [tcp udp]
	// +kubebuilder:validation:Enum=tcp;udp;
	Protocol *string `json:"protocol"`
}

ClusterLogTarget cluster log target

swagger:model ClusterLogTarget

func (*ClusterLogTarget) ContextValidate ¶ 

func (m *ClusterLogTarget) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this cluster log target based on context it is used

func (ClusterLogTarget) Diff ¶ added in v5.1.0 

func (s ClusterLogTarget) Diff(t ClusterLogTarget, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ClusterLogTarget are equal 

var a, b ClusterLogTarget
diff := a.Diff(b)

opts ...Options are ignored in this method

func (ClusterLogTarget) Equal ¶ added in v5.1.0 

func (s ClusterLogTarget) Equal(t ClusterLogTarget, opts ...Options) bool

Equal checks if two structs of type ClusterLogTarget are equal 

var a, b ClusterLogTarget
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*ClusterLogTarget) MarshalBinary ¶ 

func (m *ClusterLogTarget) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ClusterLogTarget) UnmarshalBinary ¶ 

func (m *ClusterLogTarget) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ClusterLogTarget) Validate ¶ 

func (m *ClusterLogTarget) Validate(formats strfmt.Registry) error

Validate validates this cluster log target

type ClusterSettings ¶ 

type ClusterSettings struct {

	// bootstrap key
	BootstrapKey string `json:"bootstrap_key,omitempty"`

	// cluster
	Cluster *ClusterSettingsCluster `json:"cluster,omitempty"`

	// mode
	// Enum: [single cluster]
	// +kubebuilder:validation:Enum=single;cluster;
	Mode string `json:"mode,omitempty"`

	// status
	// Read Only: true
	// Enum: [active unreachable waiting_approval]
	// +kubebuilder:validation:Enum=active;unreachable;waiting_approval;
	Status string `json:"status,omitempty"`
}

ClusterSettings Cluster Settings

Settings related to a cluster.

swagger:model cluster_settings

func (*ClusterSettings) ContextValidate ¶ 

func (m *ClusterSettings) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cluster settings based on the context it is used

func (ClusterSettings) Diff ¶ added in v5.1.0 

func (s ClusterSettings) Diff(t ClusterSettings, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ClusterSettings are equal

By default empty maps and slices are equal to nil: 

var a, b ClusterSettings
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ClusterSettings
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (ClusterSettings) Equal ¶ added in v5.1.0 

func (s ClusterSettings) Equal(t ClusterSettings, opts ...Options) bool

Equal checks if two structs of type ClusterSettings are equal

By default empty maps and slices are equal to nil: 

var a, b ClusterSettings
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ClusterSettings
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*ClusterSettings) MarshalBinary ¶ 

func (m *ClusterSettings) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ClusterSettings) UnmarshalBinary ¶ 

func (m *ClusterSettings) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ClusterSettings) Validate ¶ 

func (m *ClusterSettings) Validate(formats strfmt.Registry) error

Validate validates this cluster settings

type ClusterSettingsCluster ¶ 

type ClusterSettingsCluster struct {

	// cluster log targets
	ClusterLogTargets []*ClusterLogTarget `json:"log_targets,omitempty"`

	// address
	// Read Only: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Address string `json:"address,omitempty"`

	// api base path
	// Read Only: true
	APIBasePath string `json:"api_base_path,omitempty"`

	// cluster id
	ClusterID string `json:"cluster_id,omitempty"`

	// description
	// Read Only: true
	Description string `json:"description,omitempty"`

	// name
	// Read Only: true
	Name string `json:"name,omitempty"`

	// port
	// Read Only: true
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port *int64 `json:"port,omitempty"`
}

ClusterSettingsCluster Cluster controller information

swagger:model ClusterSettingsCluster

func (*ClusterSettingsCluster) ContextValidate ¶ 

func (m *ClusterSettingsCluster) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cluster settings cluster based on the context it is used

func (ClusterSettingsCluster) Diff ¶ added in v5.1.0 

func (s ClusterSettingsCluster) Diff(t ClusterSettingsCluster, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ClusterSettingsCluster are equal

By default empty maps and slices are equal to nil: 

var a, b ClusterSettingsCluster
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ClusterSettingsCluster
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (ClusterSettingsCluster) Equal ¶ added in v5.1.0 

func (s ClusterSettingsCluster) Equal(t ClusterSettingsCluster, opts ...Options) bool

Equal checks if two structs of type ClusterSettingsCluster are equal

By default empty maps and slices are equal to nil: 

var a, b ClusterSettingsCluster
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ClusterSettingsCluster
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*ClusterSettingsCluster) MarshalBinary ¶ 

func (m *ClusterSettingsCluster) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ClusterSettingsCluster) UnmarshalBinary ¶ 

func (m *ClusterSettingsCluster) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ClusterSettingsCluster) Validate ¶ 

func (m *ClusterSettingsCluster) Validate(formats strfmt.Registry) error

Validate validates this cluster settings cluster

type Compression ¶ 

type Compression struct {
	// algo req
	// Enum: [identity gzip deflate raw-deflate]
	// +kubebuilder:validation:Enum=identity;gzip;deflate;raw-deflate;
	AlgoReq string `json:"algo-req,omitempty"`

	// algorithms
	Algorithms []string `json:"algorithms,omitempty"`

	// algos res
	AlgosRes []string `json:"algos-res,omitempty"`

	// direction
	// Enum: [request response both]
	// +kubebuilder:validation:Enum=request;response;both;
	Direction string `json:"direction,omitempty"`

	// offload
	Offload bool `json:"offload,omitempty"`

	// types
	Types []string `json:"types,omitempty"`

	// types req
	TypesReq []string `json:"types-req,omitempty"`

	// types res
	TypesRes []string `json:"types-res,omitempty"`
}

Compression compression

swagger:model compression

func (*Compression) ContextValidate ¶ 

func (m *Compression) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this compression based on context it is used

func (Compression) Diff ¶ added in v5.1.0 

func (s Compression) Diff(t Compression, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Compression are equal

By default empty maps and slices are equal to nil: 

var a, b Compression
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Compression
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Compression) Equal ¶ added in v5.1.0 

func (s Compression) Equal(t Compression, opts ...Options) bool

Equal checks if two structs of type Compression are equal

By default empty maps and slices are equal to nil: 

var a, b Compression
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Compression
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Compression) MarshalBinary ¶ 

func (m *Compression) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Compression) UnmarshalBinary ¶ 

func (m *Compression) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Compression) Validate ¶ 

func (m *Compression) Validate(formats strfmt.Registry) error

Validate validates this compression

type ConfigStickTable ¶ 

type ConfigStickTable struct {

	// expire
	Expire *int64 `json:"expire,omitempty"`

	// keylen
	Keylen *int64 `json:"keylen,omitempty"`

	// nopurge
	Nopurge bool `json:"nopurge,omitempty"`

	// peers
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Peers string `json:"peers,omitempty"`

	// size
	Size *int64 `json:"size,omitempty"`

	// srvkey
	// Enum: [addr name]
	// +kubebuilder:validation:Enum=addr;name;
	Srvkey *string `json:"srvkey,omitempty"`

	// store
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Store string `json:"store,omitempty"`

	// type
	// Enum: [ip ipv6 integer string binary]
	// +kubebuilder:validation:Enum=ip;ipv6;integer;string;binary;
	Type string `json:"type,omitempty"`

	// write to
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	WriteTo *string `json:"write_to,omitempty"`
}

ConfigStickTable config stick table

swagger:model config_stick_table

func (*ConfigStickTable) ContextValidate ¶ 

func (m *ConfigStickTable) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this config stick table based on context it is used

func (ConfigStickTable) Diff ¶ added in v5.1.0 

func (s ConfigStickTable) Diff(t ConfigStickTable, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ConfigStickTable are equal 

var a, b ConfigStickTable
diff := a.Diff(b)

opts ...Options are ignored in this method

func (ConfigStickTable) Equal ¶ added in v5.1.0 

func (s ConfigStickTable) Equal(t ConfigStickTable, opts ...Options) bool

Equal checks if two structs of type ConfigStickTable are equal 

var a, b ConfigStickTable
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*ConfigStickTable) MarshalBinary ¶ 

func (m *ConfigStickTable) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConfigStickTable) UnmarshalBinary ¶ 

func (m *ConfigStickTable) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConfigStickTable) Validate ¶ 

func (m *ConfigStickTable) Validate(formats strfmt.Registry) error

Validate validates this config stick table

type Consul ¶ 

type Consul struct {
	// address
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Address *string `json:"address"`

	// Name of the defaults section to be used in backends created by this service
	Defaults string `json:"defaults,omitempty"`

	// description
	Description string `json:"description,omitempty"`

	// enabled
	// Required: true
	Enabled *bool `json:"enabled"`

	// Defines the health check conditions required for each node to be considered valid for the service.
	//   none: all nodes are considered valid
	//   any: a node is considered valid if any one health check is 'passing'
	//   all: a node is considered valid if all health checks are 'passing'
	//   min: a node is considered valid if the number of 'passing' checks is greater or equal to the 'health_check_policy_min' value.
	//     If the node has less health checks configured then 'health_check_policy_min' it is considered invalid.
	// Enum: [none any all min]
	// +kubebuilder:validation:Enum=none;any;all;min;
	HealthCheckPolicy *string `json:"health_check_policy,omitempty"`

	// health check policy min
	HealthCheckPolicyMin int64 `json:"health_check_policy_min,omitempty"`

	// Auto generated ID.
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ID *string `json:"id,omitempty"`

	// mode
	// Enum: [http https]
	// +kubebuilder:validation:Enum=http;https;
	Mode *string `json:"mode,omitempty"`

	// name
	Name string `json:"name,omitempty"`

	// namespace
	Namespace string `json:"namespace,omitempty"`

	// port
	// Required: true
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port *int64 `json:"port"`

	// Duration in seconds in-between data pulling requests to the consul server
	// Required: true
	// Minimum: 1
	// +kubebuilder:validation:Minimum=1
	RetryTimeout *int64 `json:"retry_timeout"`

	// server slots base
	ServerSlotsBase *int64 `json:"server_slots_base,omitempty"`

	// server slots growth increment
	ServerSlotsGrowthIncrement int64 `json:"server_slots_growth_increment,omitempty"`

	// server slots growth type
	// Enum: [linear exponential]
	// +kubebuilder:validation:Enum=linear;exponential;
	ServerSlotsGrowthType *string `json:"server_slots_growth_type,omitempty"`

	// deprecated, use service_denylist
	ServiceBlacklist []string `json:"service-blacklist,omitempty"`

	// deprecated, use service_allowlist
	ServiceWhitelist []string `json:"service-whitelist,omitempty"`

	// service allowlist
	ServiceAllowlist []string `json:"service_allowlist,omitempty"`

	// service denylist
	ServiceDenylist []string `json:"service_denylist,omitempty"`

	// Regular expression used to filter services by name.
	ServiceNameRegexp string `json:"service_name_regexp,omitempty"`

	// token
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Token string `json:"token,omitempty"`
}

Consul Consul server

Consul server configuration Example: {"address":"127.0.0.1","enabled":true,"id":"0","port":90,"retry_timeout":10}

swagger:model consul

func (*Consul) ContextValidate ¶ 

func (m *Consul) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this consul based on context it is used

func (Consul) Diff ¶ added in v5.1.0 

func (s Consul) Diff(t Consul, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Consul are equal

By default empty maps and slices are equal to nil: 

var a, b Consul
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Consul
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Consul) Equal ¶ added in v5.1.0 

func (s Consul) Equal(t Consul, opts ...Options) bool

Equal checks if two structs of type Consul are equal

By default empty maps and slices are equal to nil: 

var a, b Consul
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Consul
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Consul) MarshalBinary ¶ 

func (m *Consul) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Consul) UnmarshalBinary ¶ 

func (m *Consul) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Consul) Validate ¶ 

func (m *Consul) Validate(formats strfmt.Registry) error

Validate validates this consul

type Consuls ¶ 

type Consuls []*Consul

Consuls Consuls

Consuls array ¶

swagger:model consuls

func (Consuls) ContextValidate ¶ 

func (m Consuls) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this consuls based on the context it is used

func (Consuls) Diff ¶ added in v5.1.0 

func (s Consuls) Diff(t Consuls, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Consuls are equal

By default empty maps and slices are equal to nil: 

var a, b Consuls
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Consuls
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Consuls) Equal ¶ added in v5.1.0 

func (s Consuls) Equal(t Consuls, opts ...Options) bool

Equal checks if two structs of type Consuls are equal

By default empty maps and slices are equal to nil: 

var a, b Consuls
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Consuls
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Consuls) Validate ¶ 

func (m Consuls) Validate(formats strfmt.Registry) error

Validate validates this consuls 

type Cookie struct {

	// attrs
	Attrs []*Attr `json:"attr,omitempty"`

	// domains
	Domains []*Domain `json:"domain,omitempty"`

	// dynamic
	Dynamic bool `json:"dynamic,omitempty"`

	// httponly
	Httponly bool `json:"httponly,omitempty"`

	// indirect
	Indirect bool `json:"indirect,omitempty"`

	// maxidle
	Maxidle int64 `json:"maxidle,omitempty"`

	// maxlife
	Maxlife int64 `json:"maxlife,omitempty"`

	// name
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Name *string `json:"name"`

	// nocache
	Nocache bool `json:"nocache,omitempty"`

	// postonly
	Postonly bool `json:"postonly,omitempty"`

	// preserve
	Preserve bool `json:"preserve,omitempty"`

	// secure
	Secure bool `json:"secure,omitempty"`

	// type
	// Enum: [rewrite insert prefix]
	// +kubebuilder:validation:Enum=rewrite;insert;prefix;
	Type string `json:"type,omitempty"`
}

Cookie cookie

swagger:model cookie

func (*Cookie) ContextValidate ¶ 

func (m *Cookie) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cookie based on the context it is used

func (Cookie) Diff ¶ added in v5.1.0 

func (s Cookie) Diff(t Cookie, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Cookie are equal

By default empty maps and slices are equal to nil: 

var a, b Cookie
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Cookie
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Cookie) Equal ¶ added in v5.1.0 

func (s Cookie) Equal(t Cookie, opts ...Options) bool

Equal checks if two structs of type Cookie are equal

By default empty maps and slices are equal to nil: 

var a, b Cookie
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Cookie
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Cookie) MarshalBinary ¶ 

func (m *Cookie) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Cookie) UnmarshalBinary ¶ 

func (m *Cookie) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Cookie) Validate ¶ 

func (m *Cookie) Validate(formats strfmt.Registry) error

Validate validates this cookie

type DefaultBind ¶ 

type DefaultBind struct {
	BindParams `json:",inline"`
}

DefaultBind Default Bind

HAProxy default bind configuration ¶

swagger:model default_bind

func (*DefaultBind) ContextValidate ¶ 

func (m *DefaultBind) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this default bind based on the context it is used

func (DefaultBind) Diff ¶ added in v5.1.0 

func (s DefaultBind) Diff(t DefaultBind, opts ...Options) map[string][]interface{}

Diff checks if two structs of type DefaultBind are equal

By default empty maps and slices are equal to nil: 

var a, b DefaultBind
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b DefaultBind
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (DefaultBind) Equal ¶ added in v5.1.0 

func (s DefaultBind) Equal(t DefaultBind, opts ...Options) bool

Equal checks if two structs of type DefaultBind are equal

By default empty maps and slices are equal to nil: 

var a, b DefaultBind
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b DefaultBind
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*DefaultBind) MarshalBinary ¶ 

func (m *DefaultBind) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (DefaultBind) MarshalJSON ¶ 

func (m DefaultBind) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*DefaultBind) UnmarshalBinary ¶ 

func (m *DefaultBind) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DefaultBind) UnmarshalJSON ¶ 

func (m *DefaultBind) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*DefaultBind) Validate ¶ 

func (m *DefaultBind) Validate(formats strfmt.Registry) error

Validate validates this default bind

type DefaultServer ¶ 

type DefaultServer struct {
	ServerParams `json:",inline"`
}

DefaultServer Default Server

swagger:model default_server

func (*DefaultServer) ContextValidate ¶ 

func (m *DefaultServer) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this default server based on the context it is used

func (DefaultServer) Diff ¶ added in v5.1.0 

func (s DefaultServer) Diff(t DefaultServer, opts ...Options) map[string][]interface{}

Diff checks if two structs of type DefaultServer are equal

By default empty maps and slices are equal to nil: 

var a, b DefaultServer
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b DefaultServer
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (DefaultServer) Equal ¶ added in v5.1.0 

func (s DefaultServer) Equal(t DefaultServer, opts ...Options) bool

Equal checks if two structs of type DefaultServer are equal

By default empty maps and slices are equal to nil: 

var a, b DefaultServer
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b DefaultServer
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*DefaultServer) MarshalBinary ¶ 

func (m *DefaultServer) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (DefaultServer) MarshalJSON ¶ 

func (m DefaultServer) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*DefaultServer) UnmarshalBinary ¶ 

func (m *DefaultServer) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DefaultServer) UnmarshalJSON ¶ 

func (m *DefaultServer) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*DefaultServer) Validate ¶ 

func (m *DefaultServer) Validate(formats strfmt.Registry) error

Validate validates this default server

type Defaults ¶ 

type Defaults struct {

	// error files
	ErrorFiles []*Errorfile `json:"error_files,omitempty"`

	// error files from HTTP errors
	ErrorFilesFromHTTPErrors []*Errorfiles `json:"errorfiles_from_http_errors,omitempty"`

	// abortonclose
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Abortonclose string `json:"abortonclose,omitempty"`

	// accept invalid http request
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	AcceptInvalidHTTPRequest string `json:"accept_invalid_http_request,omitempty"`

	// accept invalid http response
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	AcceptInvalidHTTPResponse string `json:"accept_invalid_http_response,omitempty"`

	// adv check
	// Enum: [httpchk ldap-check mysql-check pgsql-check redis-check smtpchk ssl-hello-chk tcp-check]
	// +kubebuilder:validation:Enum=httpchk;ldap-check;mysql-check;pgsql-check;redis-check;smtpchk;ssl-hello-chk;tcp-check;
	AdvCheck string `json:"adv_check,omitempty"`

	// allbackups
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Allbackups string `json:"allbackups,omitempty"`

	// backlog
	Backlog *int64 `json:"backlog,omitempty"`

	// balance
	Balance *Balance `json:"balance,omitempty"`

	// bind process
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	BindProcess string `json:"bind_process,omitempty"`

	// check timeout
	CheckTimeout *int64 `json:"check_timeout,omitempty"`

	// checkcache
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Checkcache string `json:"checkcache,omitempty"`

	// clflog
	Clflog bool `json:"clflog,omitempty"`

	// client fin timeout
	ClientFinTimeout *int64 `json:"client_fin_timeout,omitempty"`

	// client timeout
	ClientTimeout *int64 `json:"client_timeout,omitempty"`

	// clitcpka
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Clitcpka string `json:"clitcpka,omitempty"`

	// clitcpka cnt
	ClitcpkaCnt *int64 `json:"clitcpka_cnt,omitempty"`

	// clitcpka idle
	ClitcpkaIdle *int64 `json:"clitcpka_idle,omitempty"`

	// clitcpka intvl
	ClitcpkaIntvl *int64 `json:"clitcpka_intvl,omitempty"`

	// compression
	Compression *Compression `json:"compression,omitempty"`

	// connect timeout
	ConnectTimeout *int64 `json:"connect_timeout,omitempty"`

	// contstats
	// Enum: [enabled]
	// +kubebuilder:validation:Enum=enabled;
	Contstats string `json:"contstats,omitempty"`

	// cookie
	Cookie *Cookie `json:"cookie,omitempty"`

	// default backend
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	DefaultBackend string `json:"default_backend,omitempty"`

	// default server
	DefaultServer *DefaultServer `json:"default_server,omitempty"`

	// disable h2 upgrade
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	DisableH2Upgrade string `json:"disable_h2_upgrade,omitempty"`

	// disabled
	Disabled bool `json:"disabled,omitempty"`

	// dontlog normal
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	DontlogNormal string `json:"dontlog_normal,omitempty"`

	// dontlognull
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Dontlognull string `json:"dontlognull,omitempty"`

	// dynamic cookie key
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	DynamicCookieKey string `json:"dynamic_cookie_key,omitempty"`

	// email alert
	EmailAlert *EmailAlert `json:"email_alert,omitempty"`

	// enabled
	Enabled bool `json:"enabled,omitempty"`

	// error log format
	ErrorLogFormat string `json:"error_log_format,omitempty"`

	// errorloc302
	Errorloc302 *Errorloc `json:"errorloc302,omitempty"`

	// errorloc303
	Errorloc303 *Errorloc `json:"errorloc303,omitempty"`

	// external check
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	ExternalCheck string `json:"external_check,omitempty"`

	// external check command
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ExternalCheckCommand string `json:"external_check_command,omitempty"`

	// external check path
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ExternalCheckPath string `json:"external_check_path,omitempty"`

	// forwardfor
	Forwardfor *Forwardfor `json:"forwardfor,omitempty"`

	// from
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	From string `json:"from,omitempty"`

	// fullconn
	Fullconn *int64 `json:"fullconn,omitempty"`

	// h1 case adjust bogus client
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	H1CaseAdjustBogusClient string `json:"h1_case_adjust_bogus_client,omitempty"`

	// h1 case adjust bogus server
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	H1CaseAdjustBogusServer string `json:"h1_case_adjust_bogus_server,omitempty"`

	// hash balance factor
	HashBalanceFactor *int64 `json:"hash_balance_factor,omitempty"`

	// hash type
	HashType *HashType `json:"hash_type,omitempty"`

	// http buffer request
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPBufferRequest string `json:"http-buffer-request,omitempty"`

	// http check
	HTTPCheck *HTTPCheck `json:"http-check,omitempty"`

	// http use htx
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPUseHtx string `json:"http-use-htx,omitempty"`

	// http connection mode
	// Enum: [httpclose http-server-close http-keep-alive]
	// +kubebuilder:validation:Enum=httpclose;http-server-close;http-keep-alive;
	HTTPConnectionMode string `json:"http_connection_mode,omitempty"`

	// http ignore probes
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPIgnoreProbes string `json:"http_ignore_probes,omitempty"`

	// http keep alive timeout
	HTTPKeepAliveTimeout *int64 `json:"http_keep_alive_timeout,omitempty"`

	// http no delay
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPNoDelay string `json:"http_no_delay,omitempty"`

	// http pretend keepalive
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPPretendKeepalive string `json:"http_pretend_keepalive,omitempty"`

	// http request timeout
	HTTPRequestTimeout *int64 `json:"http_request_timeout,omitempty"`

	// http restrict req hdr names
	// Enum: [preserve delete reject]
	// +kubebuilder:validation:Enum=preserve;delete;reject;
	HTTPRestrictReqHdrNames string `json:"http_restrict_req_hdr_names,omitempty"`

	// http reuse
	// Enum: [aggressive always never safe]
	// +kubebuilder:validation:Enum=aggressive;always;never;safe;
	HTTPReuse string `json:"http_reuse,omitempty"`

	// http send name header
	HTTPSendNameHeader *string `json:"http_send_name_header,omitempty"`

	// http use proxy header
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPUseProxyHeader string `json:"http_use_proxy_header,omitempty"`

	// httpchk params
	HttpchkParams *HttpchkParams `json:"httpchk_params,omitempty"`

	// httplog
	Httplog bool `json:"httplog,omitempty"`

	// httpslog
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Httpslog string `json:"httpslog,omitempty"`

	// idle close on response
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	IdleCloseOnResponse string `json:"idle_close_on_response,omitempty"`

	// independent streams
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	IndependentStreams string `json:"independent_streams,omitempty"`

	// load server state from file
	// Enum: [global local none]
	// +kubebuilder:validation:Enum=global;local;none;
	LoadServerStateFromFile string `json:"load_server_state_from_file,omitempty"`

	// log format
	LogFormat string `json:"log_format,omitempty"`

	// log format sd
	LogFormatSd string `json:"log_format_sd,omitempty"`

	// log health checks
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	LogHealthChecks string `json:"log_health_checks,omitempty"`

	// log separate errors
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	LogSeparateErrors string `json:"log_separate_errors,omitempty"`

	// log tag
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	LogTag string `json:"log_tag,omitempty"`

	// logasap
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Logasap string `json:"logasap,omitempty"`

	// max keep alive queue
	MaxKeepAliveQueue *int64 `json:"max_keep_alive_queue,omitempty"`

	// maxconn
	Maxconn *int64 `json:"maxconn,omitempty"`

	// mode
	// Enum: [tcp http log]
	// +kubebuilder:validation:Enum=tcp;http;log;
	Mode string `json:"mode,omitempty"`

	// monitor uri
	MonitorURI MonitorURI `json:"monitor_uri,omitempty"`

	// mysql check params
	MysqlCheckParams *MysqlCheckParams `json:"mysql_check_params,omitempty"`

	// name
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name string `json:"name,omitempty"`

	// nolinger
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Nolinger string `json:"nolinger,omitempty"`

	// originalto
	Originalto *Originalto `json:"originalto,omitempty"`

	// persist
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Persist string `json:"persist,omitempty"`

	// persist rule
	PersistRule *PersistRule `json:"persist_rule,omitempty"`

	// pgsql check params
	PgsqlCheckParams *PgsqlCheckParams `json:"pgsql_check_params,omitempty"`

	// prefer last server
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	PreferLastServer string `json:"prefer_last_server,omitempty"`

	// queue timeout
	QueueTimeout *int64 `json:"queue_timeout,omitempty"`

	// redispatch
	Redispatch *Redispatch `json:"redispatch,omitempty"`

	// retries
	Retries *int64 `json:"retries,omitempty"`

	// retry on
	RetryOn string `json:"retry_on,omitempty"`

	// server fin timeout
	ServerFinTimeout *int64 `json:"server_fin_timeout,omitempty"`

	// server timeout
	ServerTimeout *int64 `json:"server_timeout,omitempty"`

	// smtpchk params
	SmtpchkParams *SmtpchkParams `json:"smtpchk_params,omitempty"`

	// socket stats
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SocketStats string `json:"socket_stats,omitempty"`

	// source
	Source *Source `json:"source,omitempty"`

	// splice auto
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SpliceAuto string `json:"splice_auto,omitempty"`

	// splice request
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SpliceRequest string `json:"splice_request,omitempty"`

	// splice response
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SpliceResponse string `json:"splice_response,omitempty"`

	// srvtcpka
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Srvtcpka string `json:"srvtcpka,omitempty"`

	// srvtcpka cnt
	SrvtcpkaCnt *int64 `json:"srvtcpka_cnt,omitempty"`

	// srvtcpka idle
	SrvtcpkaIdle *int64 `json:"srvtcpka_idle,omitempty"`

	// srvtcpka intvl
	SrvtcpkaIntvl *int64 `json:"srvtcpka_intvl,omitempty"`

	// stats options
	StatsOptions *StatsOptions `json:"stats_options,omitempty"`

	// tarpit timeout
	TarpitTimeout *int64 `json:"tarpit_timeout,omitempty"`

	// tcp smart accept
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	TCPSmartAccept string `json:"tcp_smart_accept,omitempty"`

	// tcp smart connect
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	TCPSmartConnect string `json:"tcp_smart_connect,omitempty"`

	// tcpka
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Tcpka string `json:"tcpka,omitempty"`

	// tcplog
	Tcplog bool `json:"tcplog,omitempty"`

	// transparent
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Transparent string `json:"transparent,omitempty"`

	// tunnel timeout
	TunnelTimeout *int64 `json:"tunnel_timeout,omitempty"`

	// unique id format
	UniqueIDFormat string `json:"unique_id_format,omitempty"`

	// unique id header
	UniqueIDHeader string `json:"unique_id_header,omitempty"`
}

Defaults Defaults

HAProxy defaults configuration ¶

swagger:model defaults

func (*Defaults) ContextValidate ¶ 

func (m *Defaults) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this defaults based on the context it is used

func (Defaults) Diff ¶ added in v5.1.0 

func (s Defaults) Diff(t Defaults, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Defaults are equal

By default empty maps and slices are equal to nil: 

var a, b Defaults
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Defaults
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Defaults) Equal ¶ added in v5.1.0 

func (s Defaults) Equal(t Defaults, opts ...Options) bool

Equal checks if two structs of type Defaults are equal

By default empty maps and slices are equal to nil: 

var a, b Defaults
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Defaults
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Defaults) MarshalBinary ¶ 

func (m *Defaults) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Defaults) UnmarshalBinary ¶ 

func (m *Defaults) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Defaults) Validate ¶ 

func (m *Defaults) Validate(formats strfmt.Registry) error

Validate validates this defaults

type DefaultsSections ¶ 

type DefaultsSections []*Defaults

DefaultsSections Defaults Sections

HAProxy defaults sections array ¶

swagger:model defaults_sections

func (DefaultsSections) ContextValidate ¶ 

func (m DefaultsSections) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this defaults sections based on the context it is used

func (DefaultsSections) Diff ¶ added in v5.1.0 

func (s DefaultsSections) Diff(t DefaultsSections, opts ...Options) map[string][]interface{}

Diff checks if two structs of type DefaultsSections are equal

By default empty maps and slices are equal to nil: 

var a, b DefaultsSections
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b DefaultsSections
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (DefaultsSections) Equal ¶ added in v5.1.0 

func (s DefaultsSections) Equal(t DefaultsSections, opts ...Options) bool

Equal checks if two structs of type DefaultsSections are equal

By default empty maps and slices are equal to nil: 

var a, b DefaultsSections
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b DefaultsSections
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (DefaultsSections) Validate ¶ 

func (m DefaultsSections) Validate(formats strfmt.Registry) error

Validate validates this defaults sections

type DgramBind ¶ 

type DgramBind struct {
	// address
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Address string `json:"address,omitempty"`

	// interface
	Interface string `json:"interface,omitempty"`

	// name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Name string `json:"name,omitempty"`

	// namespace
	Namespace string `json:"namespace,omitempty"`

	// port
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port *int64 `json:"port,omitempty"`

	// port range end
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	PortRangeEnd *int64 `json:"port-range-end,omitempty"`

	// transparent
	Transparent bool `json:"transparent,omitempty"`
}

DgramBind Dgram Bind

HAProxy log forward dgram bind configuration ¶

swagger:model dgram_bind

func (*DgramBind) ContextValidate ¶ 

func (m *DgramBind) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this dgram bind based on context it is used

func (DgramBind) Diff ¶ added in v5.1.0 

func (s DgramBind) Diff(t DgramBind, opts ...Options) map[string][]interface{}

Diff checks if two structs of type DgramBind are equal 

var a, b DgramBind
diff := a.Diff(b)

opts ...Options are ignored in this method

func (DgramBind) Equal ¶ added in v5.1.0 

func (s DgramBind) Equal(t DgramBind, opts ...Options) bool

Equal checks if two structs of type DgramBind are equal 

var a, b DgramBind
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*DgramBind) MarshalBinary ¶ 

func (m *DgramBind) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DgramBind) UnmarshalBinary ¶ 

func (m *DgramBind) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DgramBind) Validate ¶ 

func (m *DgramBind) Validate(formats strfmt.Registry) error

Validate validates this dgram bind

type DgramBinds ¶ 

type DgramBinds []*DgramBind

DgramBinds Dgram Bind

HAProxy dgram bind array ¶

swagger:model dgram_binds

func (DgramBinds) ContextValidate ¶ 

func (m DgramBinds) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this dgram binds based on the context it is used

func (DgramBinds) Diff ¶ added in v5.1.0 

func (s DgramBinds) Diff(t DgramBinds, opts ...Options) map[string][]interface{}

Diff checks if two structs of type DgramBinds are equal

By default empty maps and slices are equal to nil: 

var a, b DgramBinds
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b DgramBinds
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (DgramBinds) Equal ¶ added in v5.1.0 

func (s DgramBinds) Equal(t DgramBinds, opts ...Options) bool

Equal checks if two structs of type DgramBinds are equal

By default empty maps and slices are equal to nil: 

var a, b DgramBinds
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b DgramBinds
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (DgramBinds) Validate ¶ 

func (m DgramBinds) Validate(formats strfmt.Registry) error

Validate validates this dgram binds

type Domain ¶ 

type Domain struct {
	// value
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Value string `json:"value,omitempty"`
}

Domain domain

swagger:model Domain

func (*Domain) ContextValidate ¶ 

func (m *Domain) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this domain based on context it is used

func (Domain) Diff ¶ added in v5.1.0 

func (s Domain) Diff(t Domain, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Domain are equal 

var a, b Domain
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Domain) Equal ¶ added in v5.1.0 

func (s Domain) Equal(t Domain, opts ...Options) bool

Equal checks if two structs of type Domain are equal 

var a, b Domain
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Domain) MarshalBinary ¶ 

func (m *Domain) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Domain) UnmarshalBinary ¶ 

func (m *Domain) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Domain) Validate ¶ 

func (m *Domain) Validate(formats strfmt.Registry) error

Validate validates this domain

type EmailAlert ¶ 

type EmailAlert struct {
	// from
	// Required: true
	// Pattern: ^\S+@\S+$
	// +kubebuilder:validation:Pattern=`^\S+@\S+$`
	From *string `json:"from"`

	// level
	// Enum: [emerg alert crit err warning notice info debug]
	// +kubebuilder:validation:Enum=emerg;alert;crit;err;warning;notice;info;debug;
	Level string `json:"level,omitempty"`

	// mailers
	// Required: true
	Mailers *string `json:"mailers"`

	// myhostname
	Myhostname string `json:"myhostname,omitempty"`

	// to
	// Required: true
	// Pattern: ^\S+@\S+$
	// +kubebuilder:validation:Pattern=`^\S+@\S+$`
	To *string `json:"to"`
}

EmailAlert Email Alert

Send emails for important log messages.

swagger:model email_alert

func (*EmailAlert) ContextValidate ¶ 

func (m *EmailAlert) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this email alert based on context it is used

func (EmailAlert) Diff ¶ added in v5.1.0 

func (s EmailAlert) Diff(t EmailAlert, opts ...Options) map[string][]interface{}

Diff checks if two structs of type EmailAlert are equal 

var a, b EmailAlert
diff := a.Diff(b)

opts ...Options are ignored in this method

func (EmailAlert) Equal ¶ added in v5.1.0 

func (s EmailAlert) Equal(t EmailAlert, opts ...Options) bool

Equal checks if two structs of type EmailAlert are equal 

var a, b EmailAlert
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*EmailAlert) MarshalBinary ¶ 

func (m *EmailAlert) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*EmailAlert) UnmarshalBinary ¶ 

func (m *EmailAlert) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*EmailAlert) Validate ¶ 

func (m *EmailAlert) Validate(formats strfmt.Registry) error

Validate validates this email alert

type EmailAlerts ¶ 

type EmailAlerts []*EmailAlert

EmailAlerts Email Alerts Array

Email Alerts array (corresponds to email-alert directives)

swagger:model email_alerts

func (EmailAlerts) ContextValidate ¶ 

func (m EmailAlerts) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this email alerts based on the context it is used

func (EmailAlerts) Diff ¶ added in v5.1.0 

func (s EmailAlerts) Diff(t EmailAlerts, opts ...Options) map[string][]interface{}

Diff checks if two structs of type EmailAlerts are equal

By default empty maps and slices are equal to nil: 

var a, b EmailAlerts
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b EmailAlerts
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (EmailAlerts) Equal ¶ added in v5.1.0 

func (s EmailAlerts) Equal(t EmailAlerts, opts ...Options) bool

Equal checks if two structs of type EmailAlerts are equal

By default empty maps and slices are equal to nil: 

var a, b EmailAlerts
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b EmailAlerts
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (EmailAlerts) Validate ¶ 

func (m EmailAlerts) Validate(formats strfmt.Registry) error

Validate validates this email alerts

type Endpoint ¶ 

type Endpoint struct {

	// Endpoint description
	Description string `json:"description,omitempty"`

	// Endpoint title
	Title string `json:"title,omitempty"`

	// Path to the endpoint
	URL string `json:"url,omitempty"`
}

Endpoint Endpoint

Endpoint definition ¶

swagger:model endpoint

func (*Endpoint) ContextValidate ¶ 

func (m *Endpoint) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this endpoint based on context it is used

func (Endpoint) Diff ¶ added in v5.1.0 

func (s Endpoint) Diff(t Endpoint, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Endpoint are equal 

var a, b Endpoint
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Endpoint) Equal ¶ added in v5.1.0 

func (s Endpoint) Equal(t Endpoint, opts ...Options) bool

Equal checks if two structs of type Endpoint are equal 

var a, b Endpoint
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Endpoint) MarshalBinary ¶ 

func (m *Endpoint) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Endpoint) UnmarshalBinary ¶ 

func (m *Endpoint) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Endpoint) Validate ¶ 

func (m *Endpoint) Validate(formats strfmt.Registry) error

Validate validates this endpoint

type Endpoints ¶ 

type Endpoints []*Endpoint

Endpoints Endpoints Array

Collection of endpoints ¶

swagger:model endpoints

func (Endpoints) ContextValidate ¶ 

func (m Endpoints) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this endpoints based on the context it is used

func (Endpoints) Diff ¶ added in v5.1.0 

func (s Endpoints) Diff(t Endpoints, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Endpoints are equal

By default empty maps and slices are equal to nil: 

var a, b Endpoints
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Endpoints
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Endpoints) Equal ¶ added in v5.1.0 

func (s Endpoints) Equal(t Endpoints, opts ...Options) bool

Equal checks if two structs of type Endpoints are equal

By default empty maps and slices are equal to nil: 

var a, b Endpoints
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Endpoints
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Endpoints) Validate ¶ 

func (m Endpoints) Validate(formats strfmt.Registry) error

Validate validates this endpoints

type Error ¶ 

type Error struct {

	// code
	// Required: true
	Code *int64 `json:"code"`

	// message
	// Required: true
	Message *string `json:"message"`

	// error
	Error map[string]string `json:"-"`
}

Error Error

API Error ¶

swagger:model error

func (*Error) ContextValidate ¶ 

func (m *Error) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this error based on context it is used

func (Error) Diff ¶ added in v5.1.0 

func (s Error) Diff(t Error, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Error are equal

By default empty maps and slices are equal to nil: 

var a, b Error
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Error
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Error) Equal ¶ added in v5.1.0 

func (s Error) Equal(t Error, opts ...Options) bool

Equal checks if two structs of type Error are equal

By default empty maps and slices are equal to nil: 

var a, b Error
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Error
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Error) MarshalBinary ¶ 

func (m *Error) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Error) MarshalJSON ¶ 

func (m Error) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object with additional properties into a JSON object

func (*Error) UnmarshalBinary ¶ 

func (m *Error) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Error) UnmarshalJSON ¶ 

func (m *Error) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshals this object with additional properties from JSON

func (*Error) Validate ¶ 

func (m *Error) Validate(formats strfmt.Registry) error

Validate validates this error

type Errorfile ¶ 

type Errorfile struct {
	// code
	// Enum: [200 400 401 403 404 405 407 408 410 413 425 429 500 501 502 503 504]
	// +kubebuilder:validation:Enum=200;400;401;403;404;405;407;408;410;413;425;429;500;501;502;503;504;
	Code int64 `json:"code,omitempty"`

	// file
	File string `json:"file,omitempty"`
}

Errorfile errorfile

swagger:model errorfile

func (*Errorfile) ContextValidate ¶ 

func (m *Errorfile) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this errorfile based on context it is used

func (Errorfile) Diff ¶ added in v5.1.0 

func (s Errorfile) Diff(t Errorfile, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Errorfile are equal 

var a, b Errorfile
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Errorfile) Equal ¶ added in v5.1.0 

func (s Errorfile) Equal(t Errorfile, opts ...Options) bool

Equal checks if two structs of type Errorfile are equal 

var a, b Errorfile
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Errorfile) MarshalBinary ¶ 

func (m *Errorfile) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Errorfile) UnmarshalBinary ¶ 

func (m *Errorfile) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Errorfile) Validate ¶ 

func (m *Errorfile) Validate(formats strfmt.Registry) error

Validate validates this errorfile

type Errorfiles ¶ 

type Errorfiles struct {

	// codes
	Codes []int64 `json:"codes,omitempty"`

	// name
	Name string `json:"name,omitempty"`
}

Errorfiles errorfiles

swagger:model errorfiles

func (*Errorfiles) ContextValidate ¶ 

func (m *Errorfiles) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this errorfiles based on context it is used

func (Errorfiles) Diff ¶ added in v5.1.0 

func (s Errorfiles) Diff(t Errorfiles, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Errorfiles are equal

By default empty maps and slices are equal to nil: 

var a, b Errorfiles
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Errorfiles
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Errorfiles) Equal ¶ added in v5.1.0 

func (s Errorfiles) Equal(t Errorfiles, opts ...Options) bool

Equal checks if two structs of type Errorfiles are equal

By default empty maps and slices are equal to nil: 

var a, b Errorfiles
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Errorfiles
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Errorfiles) MarshalBinary ¶ 

func (m *Errorfiles) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Errorfiles) UnmarshalBinary ¶ 

func (m *Errorfiles) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Errorfiles) Validate ¶ 

func (m *Errorfiles) Validate(formats strfmt.Registry) error

Validate validates this errorfiles

type Errorloc ¶ 

type Errorloc struct {
	// code
	// Required: true
	// Enum: [200 400 401 403 404 405 407 408 410 413 425 429 500 501 502 503 504]
	// +kubebuilder:validation:Enum=200;400;401;403;404;405;407;408;410;413;425;429;500;501;502;503;504;
	Code *int64 `json:"code"`

	// url
	// Required: true
	URL *string `json:"url"`
}

Errorloc errorloc

swagger:model errorloc

func (*Errorloc) ContextValidate ¶ 

func (m *Errorloc) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this errorloc based on context it is used

func (Errorloc) Diff ¶ added in v5.1.0 

func (s Errorloc) Diff(t Errorloc, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Errorloc are equal 

var a, b Errorloc
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Errorloc) Equal ¶ added in v5.1.0 

func (s Errorloc) Equal(t Errorloc, opts ...Options) bool

Equal checks if two structs of type Errorloc are equal 

var a, b Errorloc
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Errorloc) MarshalBinary ¶ 

func (m *Errorloc) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Errorloc) UnmarshalBinary ¶ 

func (m *Errorloc) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Errorloc) Validate ¶ 

func (m *Errorloc) Validate(formats strfmt.Registry) error

Validate validates this errorloc

type FCGIApp ¶ 

type FCGIApp struct {

	// Defines the document root on the remote host. The parameter serves to build the default value of FastCGI parameters SCRIPT_FILENAME and PATH_TRANSLATED. It is a mandatory setting.
	// Required: true
	Docroot *string `json:"docroot"`

	// Enables or disables the retrieval of variables related to connection management.
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	GetValues string `json:"get_values,omitempty"`

	// Defines the script name to append after a URI that ends with a slash ("/") to set the default value for the FastCGI parameter SCRIPT_NAME. It is an optional setting.
	Index string `json:"index,omitempty"`

	// Tells the FastCGI application whether or not to keep the connection open after it sends a response. If disabled, the FastCGI application closes the connection after responding to this request.
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	KeepConn string `json:"keep_conn,omitempty"`

	// log stderrs
	LogStderrs []*FCGILogStderr `json:"log_stderrs,omitempty"`

	// Defines the maximum number of concurrent requests this application can accept. If the FastCGI application retrieves the variable FCGI_MAX_REQS during connection establishment, it can override this option. Furthermore, if the application does not do multiplexing, it will ignore this option.
	// Minimum: 1
	// +kubebuilder:validation:Minimum=1
	MaxReqs int64 `json:"max_reqs,omitempty"`

	// Enables or disables the support of connection multiplexing. If the FastCGI application retrieves the variable FCGI_MPXS_CONNS during connection establishment, it can override this option.
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	MpxsConns string `json:"mpxs_conns,omitempty"`

	// Declares a FastCGI application
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Name string `json:"name"`

	// pass headers
	PassHeaders []*FCGIPassHeader `json:"pass_headers,omitempty"`

	// Defines a regular expression to extract the script-name and the path-info from the URI.
	// Thus, <regex> must have two captures: the first to capture the script name, and the second to capture the path- info.
	// If not defined, it does not perform matching on the URI, and does not fill the FastCGI parameters PATH_INFO and PATH_TRANSLATED.
	PathInfo string `json:"path_info,omitempty"`

	// set params
	SetParams []*FCGISetParam `json:"set_params,omitempty"`
}

FCGIApp FCGI application

HAProxy FastCGI application configuration ¶

swagger:model fcgiApp

func (*FCGIApp) ContextValidate ¶ 

func (m *FCGIApp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this fcgi app based on the context it is used

func (FCGIApp) Diff ¶ added in v5.1.0 

func (s FCGIApp) Diff(t FCGIApp, opts ...Options) map[string][]interface{}
	SkipIndex: true,
})

func (FCGIApp) Equal ¶ added in v5.1.0 

func (s FCGIApp) Equal(t FCGIApp, opts ...Options) bool
	SkipIndex: true,
})

func (*FCGIApp) MarshalBinary ¶ 

func (m *FCGIApp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*FCGIApp) UnmarshalBinary ¶ 

func (m *FCGIApp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*FCGIApp) Validate ¶ 

func (m *FCGIApp) Validate(formats strfmt.Registry) error

Validate validates this fcgi app

type FCGIApps ¶ 

type FCGIApps []*FCGIApp

FCGIApps fcgi apps

swagger:model fcgiApps

func (FCGIApps) ContextValidate ¶ 

func (m FCGIApps) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this fcgi apps based on the context it is used

func (FCGIApps) Diff ¶ added in v5.1.0 

func (s FCGIApps) Diff(t FCGIApps, opts ...Options) map[string][]interface{}

Diff checks if two structs of type FCGIApps are equal

By default empty maps and slices are equal to nil: 

var a, b FCGIApps
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b FCGIApps
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (FCGIApps) Equal ¶ added in v5.1.0 

func (s FCGIApps) Equal(t FCGIApps, opts ...Options) bool

Equal checks if two structs of type FCGIApps are equal

By default empty maps and slices are equal to nil: 

var a, b FCGIApps
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b FCGIApps
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (FCGIApps) Validate ¶ 

func (m FCGIApps) Validate(formats strfmt.Registry) error

Validate validates this fcgi apps

type FCGILogStderr ¶ 

type FCGILogStderr struct {

	// address
	Address string `json:"address,omitempty"`

	// Facility
	Facility string `json:"facility,omitempty"`

	// Format
	Format string `json:"format,omitempty"`

	// Global
	Global bool `json:"global,omitempty"`

	// Length
	Len int64 `json:"len,omitempty"`

	// Level
	Level string `json:"level,omitempty"`

	// Minimum level
	Minlevel string `json:"minlevel,omitempty"`

	// sample
	Sample *FCGILogStderrSample `json:"sample,omitempty"`
}

FCGILogStderr Enables logging of STDERR messages that the FastCGI application reports. It is an optional setting. By default, HAProxy Enterprise ignores STDERR messages.

swagger:model fcgiLogStderr

func (*FCGILogStderr) ContextValidate ¶ 

func (m *FCGILogStderr) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this fcgi log stderr based on the context it is used

func (FCGILogStderr) Diff ¶ added in v5.1.0 

func (s FCGILogStderr) Diff(t FCGILogStderr, opts ...Options) map[string][]interface{}

Diff checks if two structs of type FCGILogStderr are equal

By default empty maps and slices are equal to nil: 

var a, b FCGILogStderr
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b FCGILogStderr
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (FCGILogStderr) Equal ¶ added in v5.1.0 

func (s FCGILogStderr) Equal(t FCGILogStderr, opts ...Options) bool

Equal checks if two structs of type FCGILogStderr are equal

By default empty maps and slices are equal to nil: 

var a, b FCGILogStderr
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b FCGILogStderr
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*FCGILogStderr) MarshalBinary ¶ 

func (m *FCGILogStderr) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*FCGILogStderr) UnmarshalBinary ¶ 

func (m *FCGILogStderr) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*FCGILogStderr) Validate ¶ 

func (m *FCGILogStderr) Validate(formats strfmt.Registry) error

Validate validates this fcgi log stderr

type FCGILogStderrSample ¶ 

type FCGILogStderrSample struct {

	// Range
	// Required: true
	Ranges *string `json:"ranges"`

	// Size
	// Required: true
	Size *int64 `json:"size"`
}

FCGILogStderrSample Sample

swagger:model FCGILogStderrSample

func (*FCGILogStderrSample) ContextValidate ¶ 

func (m *FCGILogStderrSample) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this FCGI log stderr sample based on context it is used

func (FCGILogStderrSample) Diff ¶ added in v5.1.0 

func (s FCGILogStderrSample) Diff(t FCGILogStderrSample, opts ...Options) map[string][]interface{}

Diff checks if two structs of type FCGILogStderrSample are equal 

var a, b FCGILogStderrSample
diff := a.Diff(b)

opts ...Options are ignored in this method

func (FCGILogStderrSample) Equal ¶ added in v5.1.0 

func (s FCGILogStderrSample) Equal(t FCGILogStderrSample, opts ...Options) bool

Equal checks if two structs of type FCGILogStderrSample are equal 

var a, b FCGILogStderrSample
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*FCGILogStderrSample) MarshalBinary ¶ 

func (m *FCGILogStderrSample) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*FCGILogStderrSample) UnmarshalBinary ¶ 

func (m *FCGILogStderrSample) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*FCGILogStderrSample) Validate ¶ 

func (m *FCGILogStderrSample) Validate(formats strfmt.Registry) error

Validate validates this FCGI log stderr sample

type FCGIPassHeader ¶ 

type FCGIPassHeader struct {
	// cond
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond string `json:"cond,omitempty"`

	// cond test
	CondTest string `json:"cond_test,omitempty"`

	// name
	Name string `json:"name,omitempty"`
}

FCGIPassHeader Specifies the name of a request header to pass to the FastCGI application. Optionally, you can follow it with an ACL-based condition, in which case the FastCGI application evaluates it only if the condition is true. Most request headers are already available to the FastCGI application with the prefix "HTTP". Thus, you only need this directive to pass headers that are purposefully omitted. Currently, the headers "Authorization", "Proxy-Authorization", and hop-by-hop headers are omitted. Note that the headers "Content-type" and "Content-length" never pass to the FastCGI application because they are already converted into parameters.

swagger:model fcgiPassHeader

func (*FCGIPassHeader) ContextValidate ¶ 

func (m *FCGIPassHeader) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this fcgi pass header based on context it is used

func (FCGIPassHeader) Diff ¶ added in v5.1.0 

func (s FCGIPassHeader) Diff(t FCGIPassHeader, opts ...Options) map[string][]interface{}

Diff checks if two structs of type FCGIPassHeader are equal 

var a, b FCGIPassHeader
diff := a.Diff(b)

opts ...Options are ignored in this method

func (FCGIPassHeader) Equal ¶ added in v5.1.0 

func (s FCGIPassHeader) Equal(t FCGIPassHeader, opts ...Options) bool

Equal checks if two structs of type FCGIPassHeader are equal 

var a, b FCGIPassHeader
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*FCGIPassHeader) MarshalBinary ¶ 

func (m *FCGIPassHeader) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*FCGIPassHeader) UnmarshalBinary ¶ 

func (m *FCGIPassHeader) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*FCGIPassHeader) Validate ¶ 

func (m *FCGIPassHeader) Validate(formats strfmt.Registry) error

Validate validates this fcgi pass header

type FCGISetParam ¶ 

type FCGISetParam struct {
	// cond
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond string `json:"cond,omitempty"`

	// cond test
	CondTest string `json:"cond_test,omitempty"`

	// format
	Format string `json:"format,omitempty"`

	// name
	Name string `json:"name,omitempty"`
}

FCGISetParam Sets a FastCGI parameter to pass to this application. Its value, defined by <format> can take a formatted string, the same as the log directive. Optionally, you can follow it with an ACL-based condition, in which case the FastCGI application evaluates it only if the condition is true.

swagger:model fcgiSetParam

func (*FCGISetParam) ContextValidate ¶ 

func (m *FCGISetParam) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this fcgi set param based on context it is used

func (FCGISetParam) Diff ¶ added in v5.1.0 

func (s FCGISetParam) Diff(t FCGISetParam, opts ...Options) map[string][]interface{}

Diff checks if two structs of type FCGISetParam are equal 

var a, b FCGISetParam
diff := a.Diff(b)

opts ...Options are ignored in this method

func (FCGISetParam) Equal ¶ added in v5.1.0 

func (s FCGISetParam) Equal(t FCGISetParam, opts ...Options) bool

Equal checks if two structs of type FCGISetParam are equal 

var a, b FCGISetParam
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*FCGISetParam) MarshalBinary ¶ 

func (m *FCGISetParam) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*FCGISetParam) UnmarshalBinary ¶ 

func (m *FCGISetParam) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*FCGISetParam) Validate ¶ 

func (m *FCGISetParam) Validate(formats strfmt.Registry) error

Validate validates this fcgi set param

type Filter ¶ 

type Filter struct {
	// Name of the fcgi-app section this filter will use.
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	AppName string `json:"app_name,omitempty"`

	// Filter name that will be used by 'set-bandwidth-limit' actions to reference a specific bandwidth limitation filter
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	BandwidthLimitName string `json:"bandwidth_limit_name,omitempty"`

	// cache name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	CacheName string `json:"cache_name,omitempty"`

	// The max number of bytes that can be forwarded over the period.
	// The value must be specified for per-stream and shared bandwidth limitation filters.
	// It follows the HAProxy size format and is expressed in bytes.
	DefaultLimit int64 `json:"default_limit,omitempty"`

	// The default time period used to evaluate the bandwidth limitation rate.
	// It can be specified for per-stream bandwidth limitation filters only.
	// It follows the HAProxy time format and is expressed in milliseconds.
	DefaultPeriod int64 `json:"default_period,omitempty"`

	// index
	// Required: true
	// +kubebuilder:validation:Optional
	Index *int64 `json:"index"`

	// A sample expression rule.
	// It describes what elements will be analyzed, extracted, combined, and used to select which table entry to update the counters.
	// It must be specified for shared bandwidth limitation filters only.
	Key string `json:"key,omitempty"`

	// The max number of bytes that can be forwarded over the period.
	// The value must be specified for per-stream and shared bandwidth limitation filters.
	// It follows the HAProxy size format and is expressed in bytes.
	Limit int64 `json:"limit,omitempty"`

	// The optional minimum number of bytes forwarded at a time by a stream excluding the last packet that may be smaller.
	// This value can be specified for per-stream and shared bandwidth limitation filters.
	// It follows the HAProxy size format and is expressed in bytes.
	MinSize int64 `json:"min_size,omitempty"`

	// spoe config
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	SpoeConfig string `json:"spoe_config,omitempty"`

	// spoe engine
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	SpoeEngine string `json:"spoe_engine,omitempty"`

	// An optional table to be used instead of the default one, which is the stick-table declared in the current proxy.
	// It can be specified for shared bandwidth limitation filters only.
	Table string `json:"table,omitempty"`

	// trace hexdump
	TraceHexdump bool `json:"trace_hexdump,omitempty"`

	// trace name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TraceName string `json:"trace_name,omitempty"`

	// trace rnd forwarding
	TraceRndForwarding bool `json:"trace_rnd_forwarding,omitempty"`

	// trace rnd parsing
	TraceRndParsing bool `json:"trace_rnd_parsing,omitempty"`

	// type
	// Required: true
	// Enum: [bwlim-in bwlim-out cache compression fcgi-app spoe trace]
	// +kubebuilder:validation:Enum=bwlim-in;bwlim-out;cache;compression;fcgi-app;spoe;trace;
	Type string `json:"type"`
}

Filter Filter

HAProxy filters Example: {"index":0,"trace_name":"name","trace_rnd_parsing":true,"type":"trace"}

swagger:model filter

func (*Filter) ContextValidate ¶ 

func (m *Filter) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this filter based on context it is used

func (Filter) Diff ¶ added in v5.1.0 

func (s Filter) Diff(t Filter, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Filter are equal

By default empty maps and slices are equal to nil: 

var a, b Filter
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Filter
diff := a.Diff(b,Options{
	SkipIndex: true,
})

func (Filter) Equal ¶ added in v5.1.0 

func (s Filter) Equal(t Filter, opts ...Options) bool

Equal checks if two structs of type Filter are equal

By default empty maps and slices are equal to nil: 

var a, b Filter
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Filter
equal := a.Equal(b,Options{
	SkipIndex: true,
})

func (*Filter) MarshalBinary ¶ 

func (m *Filter) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Filter) UnmarshalBinary ¶ 

func (m *Filter) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Filter) Validate ¶ 

func (m *Filter) Validate(formats strfmt.Registry) error

Validate validates this filter

type Filters ¶ 

type Filters []*Filter

Filters Filters Array

HAProxy filters array (corresponds to filter directive)

swagger:model filters

func (Filters) ContextValidate ¶ 

func (m Filters) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this filters based on the context it is used

func (Filters) Diff ¶ added in v5.1.0 

func (s Filters) Diff(t Filters, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Filters are equal

By default empty maps and slices are equal to nil: 

var a, b Filters
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Filters
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Filters) Equal ¶ added in v5.1.0 

func (s Filters) Equal(t Filters, opts ...Options) bool

Equal checks if two structs of type Filters are equal

By default empty maps and slices are equal to nil: 

var a, b Filters
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Filters
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Filters) Validate ¶ 

func (m Filters) Validate(formats strfmt.Registry) error

Validate validates this filters

type ForcePersist ¶ added in v5.0.7 

type ForcePersist struct {
	// cond
	// Required: true
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond *string `json:"cond"`

	// cond test
	// Required: true
	CondTest *string `json:"cond_test"`
}

ForcePersist force persist

swagger:model ForcePersist

func (*ForcePersist) ContextValidate ¶ added in v5.0.7 

func (m *ForcePersist) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this force persist based on context it is used

func (ForcePersist) Diff ¶ added in v5.1.6 

func (s ForcePersist) Diff(t ForcePersist, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ForcePersist are equal 

var a, b ForcePersist
diff := a.Diff(b)

opts ...Options are ignored in this method

func (ForcePersist) Equal ¶ added in v5.1.6 

func (s ForcePersist) Equal(t ForcePersist, opts ...Options) bool

Equal checks if two structs of type ForcePersist are equal 

var a, b ForcePersist
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*ForcePersist) MarshalBinary ¶ added in v5.0.7 

func (m *ForcePersist) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ForcePersist) UnmarshalBinary ¶ added in v5.0.7 

func (m *ForcePersist) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ForcePersist) Validate ¶ added in v5.0.7 

func (m *ForcePersist) Validate(formats strfmt.Registry) error

Validate validates this force persist

type Forwardfor ¶ 

type Forwardfor struct {
	// enabled
	// Required: true
	// Enum: [enabled]
	// +kubebuilder:validation:Enum=enabled;
	Enabled *string `json:"enabled"`

	// except
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Except string `json:"except,omitempty"`

	// header
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Header string `json:"header,omitempty"`

	// ifnone
	Ifnone bool `json:"ifnone,omitempty"`
}

Forwardfor forwardfor

swagger:model forwardfor

func (*Forwardfor) ContextValidate ¶ 

func (m *Forwardfor) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this forwardfor based on context it is used

func (Forwardfor) Diff ¶ added in v5.1.0 

func (s Forwardfor) Diff(t Forwardfor, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Forwardfor are equal 

var a, b Forwardfor
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Forwardfor) Equal ¶ added in v5.1.0 

func (s Forwardfor) Equal(t Forwardfor, opts ...Options) bool

Equal checks if two structs of type Forwardfor are equal 

var a, b Forwardfor
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Forwardfor) MarshalBinary ¶ 

func (m *Forwardfor) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Forwardfor) UnmarshalBinary ¶ 

func (m *Forwardfor) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Forwardfor) Validate ¶ 

func (m *Forwardfor) Validate(formats strfmt.Registry) error

Validate validates this forwardfor

type Frontend ¶ 

type Frontend struct {

	// error files
	ErrorFiles []*Errorfile `json:"error_files,omitempty"`

	// error files from HTTP errors
	ErrorFilesFromHTTPErrors []*Errorfiles `json:"errorfiles_from_http_errors,omitempty"`

	// accept invalid http request
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	AcceptInvalidHTTPRequest string `json:"accept_invalid_http_request,omitempty"`

	// backlog
	Backlog *int64 `json:"backlog,omitempty"`

	// bind process
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	BindProcess string `json:"bind_process,omitempty"`

	// clflog
	Clflog bool `json:"clflog,omitempty"`

	// client fin timeout
	ClientFinTimeout *int64 `json:"client_fin_timeout,omitempty"`

	// client timeout
	ClientTimeout *int64 `json:"client_timeout,omitempty"`

	// clitcpka
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Clitcpka string `json:"clitcpka,omitempty"`

	// clitcpka cnt
	ClitcpkaCnt *int64 `json:"clitcpka_cnt,omitempty"`

	// clitcpka idle
	ClitcpkaIdle *int64 `json:"clitcpka_idle,omitempty"`

	// clitcpka intvl
	ClitcpkaIntvl *int64 `json:"clitcpka_intvl,omitempty"`

	// compression
	Compression *Compression `json:"compression,omitempty"`

	// contstats
	// Enum: [enabled]
	// +kubebuilder:validation:Enum=enabled;
	Contstats string `json:"contstats,omitempty"`

	// default backend
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	DefaultBackend string `json:"default_backend,omitempty"`

	// description
	Description string `json:"description,omitempty"`

	// disable h2 upgrade
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	DisableH2Upgrade string `json:"disable_h2_upgrade,omitempty"`

	// disabled
	Disabled bool `json:"disabled,omitempty"`

	// dontlog normal
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	DontlogNormal string `json:"dontlog_normal,omitempty"`

	// dontlognull
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Dontlognull string `json:"dontlognull,omitempty"`

	// email alert
	EmailAlert *EmailAlert `json:"email_alert,omitempty"`

	// enabled
	Enabled bool `json:"enabled,omitempty"`

	// error log format
	ErrorLogFormat string `json:"error_log_format,omitempty"`

	// errorloc302
	Errorloc302 *Errorloc `json:"errorloc302,omitempty"`

	// errorloc303
	Errorloc303 *Errorloc `json:"errorloc303,omitempty"`

	// forwardfor
	Forwardfor *Forwardfor `json:"forwardfor,omitempty"`

	// from
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	From string `json:"from,omitempty"`

	// h1 case adjust bogus client
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	H1CaseAdjustBogusClient string `json:"h1_case_adjust_bogus_client,omitempty"`

	// http buffer request
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPBufferRequest string `json:"http-buffer-request,omitempty"`

	// http use htx
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPUseHtx string `json:"http-use-htx,omitempty"`

	// http connection mode
	// Enum: [httpclose http-server-close http-keep-alive]
	// +kubebuilder:validation:Enum=httpclose;http-server-close;http-keep-alive;
	HTTPConnectionMode string `json:"http_connection_mode,omitempty"`

	// http ignore probes
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPIgnoreProbes string `json:"http_ignore_probes,omitempty"`

	// http keep alive timeout
	HTTPKeepAliveTimeout *int64 `json:"http_keep_alive_timeout,omitempty"`

	// http no delay
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPNoDelay string `json:"http_no_delay,omitempty"`

	// http request timeout
	HTTPRequestTimeout *int64 `json:"http_request_timeout,omitempty"`

	// http restrict req hdr names
	// Enum: [preserve delete reject]
	// +kubebuilder:validation:Enum=preserve;delete;reject;
	HTTPRestrictReqHdrNames string `json:"http_restrict_req_hdr_names,omitempty"`

	// http use proxy header
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HTTPUseProxyHeader string `json:"http_use_proxy_header,omitempty"`

	// httplog
	Httplog bool `json:"httplog,omitempty"`

	// httpslog
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Httpslog string `json:"httpslog,omitempty"`

	// id
	ID *int64 `json:"id,omitempty"`

	// idle close on response
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	IdleCloseOnResponse string `json:"idle_close_on_response,omitempty"`

	// independent streams
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	IndependentStreams string `json:"independent_streams,omitempty"`

	// log format
	LogFormat string `json:"log_format,omitempty"`

	// log format sd
	LogFormatSd string `json:"log_format_sd,omitempty"`

	// log separate errors
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	LogSeparateErrors string `json:"log_separate_errors,omitempty"`

	// log tag
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	LogTag string `json:"log_tag,omitempty"`

	// logasap
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Logasap string `json:"logasap,omitempty"`

	// maxconn
	Maxconn *int64 `json:"maxconn,omitempty"`

	// mode
	// Enum: [http tcp]
	// +kubebuilder:validation:Enum=http;tcp;
	Mode string `json:"mode,omitempty"`

	// monitor fail
	MonitorFail *MonitorFail `json:"monitor_fail,omitempty"`

	// monitor uri
	MonitorURI MonitorURI `json:"monitor_uri,omitempty"`

	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name string `json:"name"`

	// nolinger
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Nolinger string `json:"nolinger,omitempty"`

	// originalto
	Originalto *Originalto `json:"originalto,omitempty"`

	// socket stats
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SocketStats string `json:"socket_stats,omitempty"`

	// splice auto
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SpliceAuto string `json:"splice_auto,omitempty"`

	// splice request
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SpliceRequest string `json:"splice_request,omitempty"`

	// splice response
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SpliceResponse string `json:"splice_response,omitempty"`

	// stats options
	StatsOptions *StatsOptions `json:"stats_options,omitempty"`

	// stick table
	StickTable *ConfigStickTable `json:"stick_table,omitempty"`

	// tarpit timeout
	TarpitTimeout *int64 `json:"tarpit_timeout,omitempty"`

	// tcp smart accept
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	TCPSmartAccept string `json:"tcp_smart_accept,omitempty"`

	// tcpka
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Tcpka string `json:"tcpka,omitempty"`

	// tcplog
	Tcplog bool `json:"tcplog,omitempty"`

	// unique id format
	UniqueIDFormat string `json:"unique_id_format,omitempty"`

	// unique id header
	UniqueIDHeader string `json:"unique_id_header,omitempty"`
}

Frontend Frontend

HAProxy frontend configuration Example: {"default_backend":"test_backend","http_connection_mode":"http-keep-alive","maxconn":2000,"mode":"http","name":"test_frontend"}

swagger:model frontend

func (*Frontend) ContextValidate ¶ 

func (m *Frontend) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this frontend based on the context it is used

func (Frontend) Diff ¶ added in v5.1.0 

func (s Frontend) Diff(t Frontend, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Frontend are equal

By default empty maps and slices are equal to nil: 

var a, b Frontend
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Frontend
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Frontend) Equal ¶ added in v5.1.0 

func (s Frontend) Equal(t Frontend, opts ...Options) bool

Equal checks if two structs of type Frontend are equal

By default empty maps and slices are equal to nil: 

var a, b Frontend
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Frontend
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Frontend) MarshalBinary ¶ 

func (m *Frontend) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Frontend) UnmarshalBinary ¶ 

func (m *Frontend) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Frontend) Validate ¶ 

func (m *Frontend) Validate(formats strfmt.Registry) error

Validate validates this frontend

type Frontends ¶ 

type Frontends []*Frontend

Frontends Frontends

HAProxy frontends array ¶

swagger:model frontends

func (Frontends) ContextValidate ¶ 

func (m Frontends) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this frontends based on the context it is used

func (Frontends) Diff ¶ added in v5.1.0 

func (s Frontends) Diff(t Frontends, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Frontends are equal

By default empty maps and slices are equal to nil: 

var a, b Frontends
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Frontends
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Frontends) Equal ¶ added in v5.1.0 

func (s Frontends) Equal(t Frontends, opts ...Options) bool

Equal checks if two structs of type Frontends are equal

By default empty maps and slices are equal to nil: 

var a, b Frontends
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Frontends
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Frontends) Validate ¶ 

func (m Frontends) Validate(formats strfmt.Registry) error

Validate validates this frontends

type GeneralFile ¶ 

type GeneralFile struct {

	// description
	Description string `json:"description,omitempty"`

	// file
	File string `json:"file,omitempty"`

	// id
	ID string `json:"id,omitempty"`

	// File size in bytes.
	Size *int64 `json:"size,omitempty"`

	// storage name
	StorageName string `json:"storage_name,omitempty"`
}

GeneralFile General use file

General use file ¶

swagger:model general_file

func (*GeneralFile) ContextValidate ¶ 

func (m *GeneralFile) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this general file based on context it is used

func (GeneralFile) Diff ¶ added in v5.1.0 

func (s GeneralFile) Diff(t GeneralFile, opts ...Options) map[string][]interface{}

Diff checks if two structs of type GeneralFile are equal 

var a, b GeneralFile
diff := a.Diff(b)

opts ...Options are ignored in this method

func (GeneralFile) Equal ¶ added in v5.1.0 

func (s GeneralFile) Equal(t GeneralFile, opts ...Options) bool

Equal checks if two structs of type GeneralFile are equal 

var a, b GeneralFile
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*GeneralFile) MarshalBinary ¶ 

func (m *GeneralFile) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*GeneralFile) UnmarshalBinary ¶ 

func (m *GeneralFile) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*GeneralFile) Validate ¶ 

func (m *GeneralFile) Validate(formats strfmt.Registry) error

Validate validates this general file

type GeneralFiles ¶ 

type GeneralFiles []*GeneralFile

GeneralFiles General Files Array

Array of general use files ¶

swagger:model general_files

func (GeneralFiles) ContextValidate ¶ 

func (m GeneralFiles) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this general files based on the context it is used

func (GeneralFiles) Diff ¶ added in v5.1.0 

func (s GeneralFiles) Diff(t GeneralFiles, opts ...Options) map[string][]interface{}

Diff checks if two structs of type GeneralFiles are equal

By default empty maps and slices are equal to nil: 

var a, b GeneralFiles
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b GeneralFiles
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (GeneralFiles) Equal ¶ added in v5.1.0 

func (s GeneralFiles) Equal(t GeneralFiles, opts ...Options) bool

Equal checks if two structs of type GeneralFiles are equal

By default empty maps and slices are equal to nil: 

var a, b GeneralFiles
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b GeneralFiles
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (GeneralFiles) Validate ¶ 

func (m GeneralFiles) Validate(formats strfmt.Registry) error

Validate validates this general files

type Global ¶ 

type Global struct {

	// CPU maps
	CPUMaps []*CPUMap `json:"cpu_maps,omitempty"`

	// h1 case adjusts
	H1CaseAdjusts []*H1CaseAdjust `json:"h1_case_adjust,omitempty"`

	// preset envs
	PresetEnvs []*PresetEnv `json:"presetenv,omitempty"`

	// runtime a p is
	RuntimeAPIs []*RuntimeAPI `json:"runtime_apis,omitempty"`

	// set envs
	SetEnvs []*SetEnv `json:"setenv,omitempty"`

	// set var fmts
	SetVarFmts []*SetVarFmt `json:"set_var_fmt,omitempty"`

	// set vars
	SetVars []*SetVar `json:"set_var,omitempty"`

	// ssl engines
	SslEngines []*SslEngine `json:"ssl_engines,omitempty"`

	// thread group lines
	ThreadGroupLines []*ThreadGroup `json:"thread_group_lines,omitempty"`

	// anonkey
	// Maximum: 4.294967295e+09
	// Minimum: 0
	// +kubebuilder:validation:Maximum=4.294967295e+09
	// +kubebuilder:validation:Minimum=0
	Anonkey *int64 `json:"anonkey,omitempty"`

	// busy polling
	BusyPolling bool `json:"busy_polling,omitempty"`

	// ca base
	CaBase string `json:"ca_base,omitempty"`

	// chroot
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Chroot string `json:"chroot,omitempty"`

	// close spread time
	CloseSpreadTime *int64 `json:"close_spread_time,omitempty"`

	// cluster secret
	ClusterSecret string `json:"cluster_secret,omitempty"`

	// crt base
	CrtBase string `json:"crt_base,omitempty"`

	// daemon
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Daemon string `json:"daemon,omitempty"`

	// default path
	DefaultPath *GlobalDefaultPath `json:"default_path,omitempty"`

	// description
	Description string `json:"description,omitempty"`

	// device atlas options
	DeviceAtlasOptions *GlobalDeviceAtlasOptions `json:"device_atlas_options,omitempty"`

	// expose experimental directives
	ExposeExperimentalDirectives bool `json:"expose_experimental_directives,omitempty"`

	// external check
	ExternalCheck bool `json:"external_check,omitempty"`

	// fifty one degrees options
	FiftyOneDegreesOptions *GlobalFiftyOneDegreesOptions `json:"fifty_one_degrees_options,omitempty"`

	// gid
	Gid int64 `json:"gid,omitempty"`

	// grace
	Grace *int64 `json:"grace,omitempty"`

	// group
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Group string `json:"group,omitempty"`

	// h1 accept payload with any method
	H1AcceptPayloadWithAnyMethod bool `json:"h1_accept_payload_with_any_method,omitempty"`

	// h1 case adjust file
	H1CaseAdjustFile string `json:"h1_case_adjust_file,omitempty"`

	// h1 do not close on insecure transfer encoding
	H1DoNotCloseOnInsecureTransferEncoding bool `json:"h1_do_not_close_on_insecure_transfer_encoding,omitempty"`

	// h2 workaround bogus websocket clients
	H2WorkaroundBogusWebsocketClients bool `json:"h2_workaround_bogus_websocket_clients,omitempty"`

	// hard stop after
	HardStopAfter *int64 `json:"hard_stop_after,omitempty"`

	// httpclient resolvers disabled
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	HttpclientResolversDisabled string `json:"httpclient_resolvers_disabled,omitempty"`

	// httpclient resolvers id
	HttpclientResolversID string `json:"httpclient_resolvers_id,omitempty"`

	// httpclient resolvers prefer
	// Enum: [ipv4 ipv6]
	// +kubebuilder:validation:Enum=ipv4;ipv6;
	HttpclientResolversPrefer string `json:"httpclient_resolvers_prefer,omitempty"`

	// httpclient retries
	HttpclientRetries int64 `json:"httpclient_retries,omitempty"`

	// httpclient ssl ca file
	HttpclientSslCaFile string `json:"httpclient_ssl_ca_file,omitempty"`

	// httpclient ssl verify
	// Enum: [ none required]
	// +kubebuilder:validation:Enum="";none;required;
	HttpclientSslVerify *string `json:"httpclient_ssl_verify,omitempty"`

	// httpclient timeout connect
	HttpclientTimeoutConnect *int64 `json:"httpclient_timeout_connect,omitempty"`

	// insecure fork wanted
	InsecureForkWanted bool `json:"insecure_fork_wanted,omitempty"`

	// insecure setuid wanted
	InsecureSetuidWanted bool `json:"insecure_setuid_wanted,omitempty"`

	// issuers chain path
	IssuersChainPath string `json:"issuers_chain_path,omitempty"`

	// limited quic
	LimitedQuic bool `json:"limited_quic,omitempty"`

	// load server state from file
	// Enum: [global local none]
	// +kubebuilder:validation:Enum=global;local;none;
	LoadServerStateFromFile string `json:"load_server_state_from_file,omitempty"`

	// localpeer
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Localpeer string `json:"localpeer,omitempty"`

	// log send hostname
	LogSendHostname *GlobalLogSendHostname `json:"log_send_hostname,omitempty"`

	// lua load per thread
	LuaLoadPerThread string `json:"lua_load_per_thread,omitempty"`

	// lua loads
	LuaLoads []*LuaLoad `json:"lua_loads,omitempty"`

	// lua prepend path
	LuaPrependPath []*LuaPrependPath `json:"lua_prepend_path,omitempty"`

	// master worker
	MasterWorker bool `json:"master-worker,omitempty"`

	// max spread checks
	MaxSpreadChecks *int64 `json:"max_spread_checks,omitempty"`

	// maxcompcpuusage
	Maxcompcpuusage int64 `json:"maxcompcpuusage,omitempty"`

	// maxcomprate
	Maxcomprate int64 `json:"maxcomprate,omitempty"`

	// maxconn
	Maxconn int64 `json:"maxconn,omitempty"`

	// maxconnrate
	Maxconnrate int64 `json:"maxconnrate,omitempty"`

	// maxpipes
	Maxpipes int64 `json:"maxpipes,omitempty"`

	// maxsessrate
	Maxsessrate int64 `json:"maxsessrate,omitempty"`

	// maxsslconn
	Maxsslconn int64 `json:"maxsslconn,omitempty"`

	// maxsslrate
	Maxsslrate int64 `json:"maxsslrate,omitempty"`

	// maxzlibmem
	Maxzlibmem int64 `json:"maxzlibmem,omitempty"`

	// mworker max reloads
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	MworkerMaxReloads *int64 `json:"mworker_max_reloads,omitempty"`

	// nbproc
	Nbproc int64 `json:"nbproc,omitempty"`

	// nbthread
	Nbthread int64 `json:"nbthread,omitempty"`

	// no quic
	NoQuic bool `json:"no-quic,omitempty"`

	// node
	Node string `json:"node,omitempty"`

	// noepoll
	Noepoll bool `json:"noepoll,omitempty"`

	// noevports
	Noevports bool `json:"noevports,omitempty"`

	// nogetaddrinfo
	Nogetaddrinfo bool `json:"nogetaddrinfo,omitempty"`

	// nokqueue
	Nokqueue bool `json:"nokqueue,omitempty"`

	// nopoll
	Nopoll bool `json:"nopoll,omitempty"`

	// noreuseport
	Noreuseport bool `json:"noreuseport,omitempty"`

	// nosplice
	Nosplice bool `json:"nosplice,omitempty"`

	// numa cpu mapping
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	NumaCPUMapping string `json:"numa_cpu_mapping,omitempty"`

	// pidfile
	Pidfile string `json:"pidfile,omitempty"`

	// pp2 never send local
	Pp2NeverSendLocal bool `json:"pp2_never_send_local,omitempty"`

	// prealloc fd
	PreallocFd bool `json:"prealloc-fd,omitempty"`

	// profiling tasks
	// Enum: [auto on off]
	// +kubebuilder:validation:Enum=auto;on;off;
	ProfilingTasks string `json:"profiling_tasks,omitempty"`

	// quiet
	Quiet bool `json:"quiet,omitempty"`

	// resetenv
	Resetenv string `json:"resetenv,omitempty"`

	// server state base
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ServerStateBase string `json:"server_state_base,omitempty"`

	// server state file
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ServerStateFile string `json:"server_state_file,omitempty"`

	// set dumpable
	SetDumpable bool `json:"set_dumpable,omitempty"`

	// setcap
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Setcap string `json:"setcap,omitempty"`

	// spread checks
	SpreadChecks int64 `json:"spread_checks,omitempty"`

	// ssl default bind ciphers
	SslDefaultBindCiphers string `json:"ssl_default_bind_ciphers,omitempty"`

	// ssl default bind ciphersuites
	SslDefaultBindCiphersuites string `json:"ssl_default_bind_ciphersuites,omitempty"`

	// ssl default bind client sigalgs
	SslDefaultBindClientSigalgs string `json:"ssl_default_bind_client_sigalgs,omitempty"`

	// ssl default bind curves
	SslDefaultBindCurves string `json:"ssl_default_bind_curves,omitempty"`

	// ssl default bind options
	SslDefaultBindOptions string `json:"ssl_default_bind_options,omitempty"`

	// ssl default bind sigalgs
	SslDefaultBindSigalgs string `json:"ssl_default_bind_sigalgs,omitempty"`

	// ssl default server ciphers
	SslDefaultServerCiphers string `json:"ssl_default_server_ciphers,omitempty"`

	// ssl default server ciphersuites
	SslDefaultServerCiphersuites string `json:"ssl_default_server_ciphersuites,omitempty"`

	// ssl default server client sigalgs
	SslDefaultServerClientSigalgs string `json:"ssl_default_server_client_sigalgs,omitempty"`

	// ssl default server curves
	SslDefaultServerCurves string `json:"ssl_default_server_curves,omitempty"`

	// ssl default server options
	SslDefaultServerOptions string `json:"ssl_default_server_options,omitempty"`

	// ssl default server sigalgs
	SslDefaultServerSigalgs string `json:"ssl_default_server_sigalgs,omitempty"`

	// ssl dh param file
	SslDhParamFile string `json:"ssl_dh_param_file,omitempty"`

	// ssl load extra files
	SslLoadExtraFiles string `json:"ssl_load_extra_files,omitempty"`

	// ssl mode async
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SslModeAsync string `json:"ssl_mode_async,omitempty"`

	// ssl propquery
	SslPropquery string `json:"ssl_propquery,omitempty"`

	// ssl provider
	SslProvider string `json:"ssl_provider,omitempty"`

	// ssl provider path
	SslProviderPath string `json:"ssl_provider_path,omitempty"`

	// ssl server verify
	// Enum: [none required]
	// +kubebuilder:validation:Enum=none;required;
	SslServerVerify string `json:"ssl_server_verify,omitempty"`

	// ssl skip self issued ca
	SslSkipSelfIssuedCa bool `json:"ssl_skip_self_issued_ca,omitempty"`

	// stats maxconn
	StatsMaxconn *int64 `json:"stats_maxconn,omitempty"`

	// stats timeout
	StatsTimeout *int64 `json:"stats_timeout,omitempty"`

	// strict limits
	StrictLimits bool `json:"strict_limits,omitempty"`

	// thread groups
	ThreadGroups int64 `json:"thread_groups,omitempty"`

	// tune options
	TuneOptions *GlobalTuneOptions `json:"tune_options,omitempty"`

	// tune ssl default dh param
	TuneSslDefaultDhParam int64 `json:"tune_ssl_default_dh_param,omitempty"`

	// uid
	UID int64 `json:"uid,omitempty"`

	// ulimit n
	Ulimitn int64 `json:"ulimit_n,omitempty"`

	// unsetenv
	Unsetenv string `json:"unsetenv,omitempty"`

	// user
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	User string `json:"user,omitempty"`

	// wurfl options
	WurflOptions *GlobalWurflOptions `json:"wurfl_options,omitempty"`

	// zero warning
	ZeroWarning bool `json:"zero_warning,omitempty"`
}

Global Global

HAProxy global configuration ¶

swagger:model global

func (*Global) ContextValidate ¶ 

func (m *Global) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this global based on the context it is used

func (Global) Diff ¶ added in v5.1.0 

func (s Global) Diff(t Global, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Global are equal

By default empty maps and slices are equal to nil: 

var a, b Global
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Global
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Global) Equal ¶ added in v5.1.0 

func (s Global) Equal(t Global, opts ...Options) bool

Equal checks if two structs of type Global are equal

By default empty maps and slices are equal to nil: 

var a, b Global
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Global
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Global) MarshalBinary ¶ 

func (m *Global) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Global) UnmarshalBinary ¶ 

func (m *Global) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Global) Validate ¶ 

func (m *Global) Validate(formats strfmt.Registry) error

Validate validates this global

type GlobalDefaultPath ¶ 

type GlobalDefaultPath struct {
	// path
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Path string `json:"path,omitempty"`

	// type
	// Required: true
	// Enum: [current config parent origin]
	// +kubebuilder:validation:Enum=current;config;parent;origin;
	Type string `json:"type"`
}

GlobalDefaultPath global default path

swagger:model GlobalDefaultPath

func (*GlobalDefaultPath) ContextValidate ¶ 

func (m *GlobalDefaultPath) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this global default path based on context it is used

func (GlobalDefaultPath) Diff ¶ added in v5.1.0 

func (s GlobalDefaultPath) Diff(t GlobalDefaultPath, opts ...Options) map[string][]interface{}

Diff checks if two structs of type GlobalDefaultPath are equal 

var a, b GlobalDefaultPath
diff := a.Diff(b)

opts ...Options are ignored in this method

func (GlobalDefaultPath) Equal ¶ added in v5.1.0 

func (s GlobalDefaultPath) Equal(t GlobalDefaultPath, opts ...Options) bool

Equal checks if two structs of type GlobalDefaultPath are equal 

var a, b GlobalDefaultPath
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*GlobalDefaultPath) MarshalBinary ¶ 

func (m *GlobalDefaultPath) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*GlobalDefaultPath) UnmarshalBinary ¶ 

func (m *GlobalDefaultPath) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*GlobalDefaultPath) Validate ¶ 

func (m *GlobalDefaultPath) Validate(formats strfmt.Registry) error

Validate validates this global default path

type GlobalDeviceAtlasOptions ¶ 

type GlobalDeviceAtlasOptions struct {

	// json file
	JSONFile string `json:"json_file,omitempty"`

	// log level
	LogLevel string `json:"log_level,omitempty"`

	// properties cookie
	PropertiesCookie string `json:"properties_cookie,omitempty"`

	// separator
	Separator string `json:"separator,omitempty"`
}

GlobalDeviceAtlasOptions global device atlas options

swagger:model GlobalDeviceAtlasOptions

func (*GlobalDeviceAtlasOptions) ContextValidate ¶ 

func (m *GlobalDeviceAtlasOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this global device atlas options based on context it is used

func (GlobalDeviceAtlasOptions) Diff ¶ added in v5.1.0 

func (s GlobalDeviceAtlasOptions) Diff(t GlobalDeviceAtlasOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type GlobalDeviceAtlasOptions are equal 

var a, b GlobalDeviceAtlasOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (GlobalDeviceAtlasOptions) Equal ¶ added in v5.1.0 

func (s GlobalDeviceAtlasOptions) Equal(t GlobalDeviceAtlasOptions, opts ...Options) bool

Equal checks if two structs of type GlobalDeviceAtlasOptions are equal 

var a, b GlobalDeviceAtlasOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*GlobalDeviceAtlasOptions) MarshalBinary ¶ 

func (m *GlobalDeviceAtlasOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*GlobalDeviceAtlasOptions) UnmarshalBinary ¶ 

func (m *GlobalDeviceAtlasOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*GlobalDeviceAtlasOptions) Validate ¶ 

func (m *GlobalDeviceAtlasOptions) Validate(formats strfmt.Registry) error

Validate validates this global device atlas options

type GlobalFiftyOneDegreesOptions ¶ 

type GlobalFiftyOneDegreesOptions struct {

	// cache size
	CacheSize int64 `json:"cache_size,omitempty"`

	// data file
	DataFile string `json:"data_file,omitempty"`

	// property name list
	PropertyNameList string `json:"property_name_list,omitempty"`

	// property separator
	PropertySeparator string `json:"property_separator,omitempty"`
}

GlobalFiftyOneDegreesOptions global fifty one degrees options

swagger:model GlobalFiftyOneDegreesOptions

func (*GlobalFiftyOneDegreesOptions) ContextValidate ¶ 

func (m *GlobalFiftyOneDegreesOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this global fifty one degrees options based on context it is used

func (GlobalFiftyOneDegreesOptions) Diff ¶ added in v5.1.0 

func (s GlobalFiftyOneDegreesOptions) Diff(t GlobalFiftyOneDegreesOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type GlobalFiftyOneDegreesOptions are equal 

var a, b GlobalFiftyOneDegreesOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (GlobalFiftyOneDegreesOptions) Equal ¶ added in v5.1.0 

func (s GlobalFiftyOneDegreesOptions) Equal(t GlobalFiftyOneDegreesOptions, opts ...Options) bool

Equal checks if two structs of type GlobalFiftyOneDegreesOptions are equal 

var a, b GlobalFiftyOneDegreesOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*GlobalFiftyOneDegreesOptions) MarshalBinary ¶ 

func (m *GlobalFiftyOneDegreesOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*GlobalFiftyOneDegreesOptions) UnmarshalBinary ¶ 

func (m *GlobalFiftyOneDegreesOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*GlobalFiftyOneDegreesOptions) Validate ¶ 

func (m *GlobalFiftyOneDegreesOptions) Validate(formats strfmt.Registry) error

Validate validates this global fifty one degrees options

type GlobalLogSendHostname ¶ 

type GlobalLogSendHostname struct {
	// enabled
	// Required: true
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Enabled *string `json:"enabled"`

	// param
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Param string `json:"param,omitempty"`
}

GlobalLogSendHostname global log send hostname

swagger:model GlobalLogSendHostname

func (*GlobalLogSendHostname) ContextValidate ¶ 

func (m *GlobalLogSendHostname) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this global log send hostname based on context it is used

func (GlobalLogSendHostname) Diff ¶ added in v5.1.0 

func (s GlobalLogSendHostname) Diff(t GlobalLogSendHostname, opts ...Options) map[string][]interface{}

Diff checks if two structs of type GlobalLogSendHostname are equal 

var a, b GlobalLogSendHostname
diff := a.Diff(b)

opts ...Options are ignored in this method

func (GlobalLogSendHostname) Equal ¶ added in v5.1.0 

func (s GlobalLogSendHostname) Equal(t GlobalLogSendHostname, opts ...Options) bool

Equal checks if two structs of type GlobalLogSendHostname are equal 

var a, b GlobalLogSendHostname
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*GlobalLogSendHostname) MarshalBinary ¶ 

func (m *GlobalLogSendHostname) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*GlobalLogSendHostname) UnmarshalBinary ¶ 

func (m *GlobalLogSendHostname) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*GlobalLogSendHostname) Validate ¶ 

func (m *GlobalLogSendHostname) Validate(formats strfmt.Registry) error

Validate validates this global log send hostname

type GlobalTuneOptions ¶ 

type GlobalTuneOptions struct {

	// buffers limit
	BuffersLimit *int64 `json:"buffers_limit,omitempty"`

	// buffers reserve
	// Minimum: 2
	// +kubebuilder:validation:Minimum=2
	BuffersReserve int64 `json:"buffers_reserve,omitempty"`

	// bufsize
	Bufsize int64 `json:"bufsize,omitempty"`

	// comp maxlevel
	CompMaxlevel int64 `json:"comp_maxlevel,omitempty"`

	// disable zero copy forwarding
	DisableZeroCopyForwarding bool `json:"disable_zero_copy_forwarding,omitempty"`

	// events max events at once
	// Maximum: 10000
	// Minimum: 1
	// +kubebuilder:validation:Maximum=10000
	// +kubebuilder:validation:Minimum=1
	EventsMaxEventsAtOnce int64 `json:"events_max_events_at_once,omitempty"`

	// fail alloc
	FailAlloc bool `json:"fail_alloc,omitempty"`

	// fd edge triggered
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	FdEdgeTriggered string `json:"fd_edge_triggered,omitempty"`

	// h1 zero copy fwd recv
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	H1ZeroCopyFwdRecv string `json:"h1_zero_copy_fwd_recv,omitempty"`

	// h1 zero copy fwd send
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	H1ZeroCopyFwdSend string `json:"h1_zero_copy_fwd_send,omitempty"`

	// h2 be initial window size
	H2BeInitialWindowSize int64 `json:"h2_be_initial_window_size,omitempty"`

	// h2 be max concurrent streams
	H2BeMaxConcurrentStreams int64 `json:"h2_be_max_concurrent_streams,omitempty"`

	// h2 fe initial window size
	H2FeInitialWindowSize int64 `json:"h2_fe_initial_window_size,omitempty"`

	// h2 fe max concurrent streams
	H2FeMaxConcurrentStreams int64 `json:"h2_fe_max_concurrent_streams,omitempty"`

	// h2 header table size
	// Maximum: 65535
	// +kubebuilder:validation:Maximum=65535
	H2HeaderTableSize int64 `json:"h2_header_table_size,omitempty"`

	// h2 initial window size
	H2InitialWindowSize *int64 `json:"h2_initial_window_size,omitempty"`

	// h2 max concurrent streams
	H2MaxConcurrentStreams int64 `json:"h2_max_concurrent_streams,omitempty"`

	// h2 max frame size
	H2MaxFrameSize int64 `json:"h2_max_frame_size,omitempty"`

	// h2 zero copy fwd send
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	H2ZeroCopyFwdSend string `json:"h2_zero_copy_fwd_send,omitempty"`

	// http cookielen
	HTTPCookielen int64 `json:"http_cookielen,omitempty"`

	// http logurilen
	HTTPLogurilen int64 `json:"http_logurilen,omitempty"`

	// http maxhdr
	// Maximum: 32767
	// Minimum: 1
	// +kubebuilder:validation:Maximum=32767
	// +kubebuilder:validation:Minimum=1
	HTTPMaxhdr int64 `json:"http_maxhdr,omitempty"`

	// idle pool shared
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	IdlePoolShared string `json:"idle_pool_shared,omitempty"`

	// idletimer
	// Maximum: 65535
	// Minimum: 0
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=0
	Idletimer *int64 `json:"idletimer,omitempty"`

	// listener default shards
	// Enum: [by-process by-thread by-group]
	// +kubebuilder:validation:Enum=by-process;by-thread;by-group;
	ListenerDefaultShards string `json:"listener_default_shards,omitempty"`

	// listener multi queue
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	ListenerMultiQueue string `json:"listener_multi_queue,omitempty"`

	// lua burst timeout
	LuaBurstTimeout *int64 `json:"lua_burst_timeout,omitempty"`

	// lua forced yield
	LuaForcedYield int64 `json:"lua_forced_yield,omitempty"`

	// lua log loggers
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	LuaLogLoggers string `json:"lua_log_loggers,omitempty"`

	// lua log stderr
	// Enum: [auto enabled disabled]
	// +kubebuilder:validation:Enum=auto;enabled;disabled;
	LuaLogStderr string `json:"lua_log_stderr,omitempty"`

	// lua maxmem
	LuaMaxmem bool `json:"lua_maxmem,omitempty"`

	// lua service timeout
	LuaServiceTimeout *int64 `json:"lua_service_timeout,omitempty"`

	// lua session timeout
	LuaSessionTimeout *int64 `json:"lua_session_timeout,omitempty"`

	// lua task timeout
	LuaTaskTimeout *int64 `json:"lua_task_timeout,omitempty"`

	// max checks per thread
	MaxChecksPerThread *int64 `json:"max_checks_per_thread,omitempty"`

	// maxaccept
	Maxaccept int64 `json:"maxaccept,omitempty"`

	// maxpollevents
	Maxpollevents int64 `json:"maxpollevents,omitempty"`

	// maxrewrite
	Maxrewrite int64 `json:"maxrewrite,omitempty"`

	// memory hot size
	MemoryHotSize *int64 `json:"memory_hot_size,omitempty"`

	// pattern cache size
	PatternCacheSize *int64 `json:"pattern_cache_size,omitempty"`

	// peers max updates at once
	PeersMaxUpdatesAtOnce int64 `json:"peers_max_updates_at_once,omitempty"`

	// pipesize
	Pipesize int64 `json:"pipesize,omitempty"`

	// pool high fd ratio
	PoolHighFdRatio int64 `json:"pool_high_fd_ratio,omitempty"`

	// pool low fd ratio
	PoolLowFdRatio int64 `json:"pool_low_fd_ratio,omitempty"`

	// pt zero copy forwarding
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	PtZeroCopyForwarding string `json:"pt_zero_copy_forwarding,omitempty"`

	// quic frontend conn tx buffers limit
	QuicFrontendConnTxBuffersLimit *int64 `json:"quic_frontend_conn_tx_buffers_limit,omitempty"`

	// quic frontend max idle timeout
	QuicFrontendMaxIdleTimeout *int64 `json:"quic_frontend_max_idle_timeout,omitempty"`

	// quic frontend max streams bidi
	QuicFrontendMaxStreamsBidi *int64 `json:"quic_frontend_max_streams_bidi,omitempty"`

	// quic max frame loss
	QuicMaxFrameLoss *int64 `json:"quic_max_frame_loss,omitempty"`

	// quic retry threshold
	QuicRetryThreshold *int64 `json:"quic_retry_threshold,omitempty"`

	// quic socket owner
	// Enum: [listener connection]
	// +kubebuilder:validation:Enum=listener;connection;
	QuicSocketOwner string `json:"quic_socket_owner,omitempty"`

	// rcvbuf backend
	RcvbufBackend *int64 `json:"rcvbuf_backend,omitempty"`

	// rcvbuf client
	RcvbufClient *int64 `json:"rcvbuf_client,omitempty"`

	// rcvbuf frontend
	RcvbufFrontend *int64 `json:"rcvbuf_frontend,omitempty"`

	// rcvbuf server
	RcvbufServer *int64 `json:"rcvbuf_server,omitempty"`

	// recv enough
	RecvEnough int64 `json:"recv_enough,omitempty"`

	// runqueue depth
	RunqueueDepth int64 `json:"runqueue_depth,omitempty"`

	// sched low latency
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SchedLowLatency string `json:"sched_low_latency,omitempty"`

	// sndbuf backend
	SndbufBackend *int64 `json:"sndbuf_backend,omitempty"`

	// sndbuf client
	SndbufClient *int64 `json:"sndbuf_client,omitempty"`

	// sndbuf frontend
	SndbufFrontend *int64 `json:"sndbuf_frontend,omitempty"`

	// sndbuf server
	SndbufServer *int64 `json:"sndbuf_server,omitempty"`

	// ssl cachesize
	SslCachesize *int64 `json:"ssl_cachesize,omitempty"`

	// ssl capture buffer size
	SslCaptureBufferSize *int64 `json:"ssl_capture_buffer_size,omitempty"`

	// ssl ctx cache size
	SslCtxCacheSize int64 `json:"ssl_ctx_cache_size,omitempty"`

	// ssl default dh param
	SslDefaultDhParam int64 `json:"ssl_default_dh_param,omitempty"`

	// ssl force private cache
	SslForcePrivateCache bool `json:"ssl_force_private_cache,omitempty"`

	// ssl keylog
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SslKeylog string `json:"ssl_keylog,omitempty"`

	// ssl lifetime
	SslLifetime *int64 `json:"ssl_lifetime,omitempty"`

	// ssl maxrecord
	SslMaxrecord *int64 `json:"ssl_maxrecord,omitempty"`

	// ssl ocsp update max delay
	SslOcspUpdateMaxDelay *int64 `json:"ssl_ocsp_update_max_delay,omitempty"`

	// ssl ocsp update min delay
	SslOcspUpdateMinDelay *int64 `json:"ssl_ocsp_update_min_delay,omitempty"`

	// stick counters
	StickCounters *int64 `json:"stick_counters,omitempty"`

	// vars global max size
	VarsGlobalMaxSize *int64 `json:"vars_global_max_size,omitempty"`

	// vars proc max size
	VarsProcMaxSize *int64 `json:"vars_proc_max_size,omitempty"`

	// vars reqres max size
	VarsReqresMaxSize *int64 `json:"vars_reqres_max_size,omitempty"`

	// vars sess max size
	VarsSessMaxSize *int64 `json:"vars_sess_max_size,omitempty"`

	// vars txn max size
	VarsTxnMaxSize *int64 `json:"vars_txn_max_size,omitempty"`

	// zlib memlevel
	// Maximum: 9
	// Minimum: 1
	// +kubebuilder:validation:Maximum=9
	// +kubebuilder:validation:Minimum=1
	ZlibMemlevel int64 `json:"zlib_memlevel,omitempty"`

	// zlib windowsize
	// Maximum: 15
	// Minimum: 8
	// +kubebuilder:validation:Maximum=15
	// +kubebuilder:validation:Minimum=8
	ZlibWindowsize int64 `json:"zlib_windowsize,omitempty"`
}

GlobalTuneOptions global tune options

swagger:model GlobalTuneOptions

func (*GlobalTuneOptions) ContextValidate ¶ 

func (m *GlobalTuneOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this global tune options based on context it is used

func (GlobalTuneOptions) Diff ¶ added in v5.1.0 

func (s GlobalTuneOptions) Diff(t GlobalTuneOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type GlobalTuneOptions are equal 

var a, b GlobalTuneOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (GlobalTuneOptions) Equal ¶ added in v5.1.0 

func (s GlobalTuneOptions) Equal(t GlobalTuneOptions, opts ...Options) bool

Equal checks if two structs of type GlobalTuneOptions are equal 

var a, b GlobalTuneOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*GlobalTuneOptions) MarshalBinary ¶ 

func (m *GlobalTuneOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*GlobalTuneOptions) UnmarshalBinary ¶ 

func (m *GlobalTuneOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*GlobalTuneOptions) Validate ¶ 

func (m *GlobalTuneOptions) Validate(formats strfmt.Registry) error

Validate validates this global tune options

type GlobalWurflOptions ¶ 

type GlobalWurflOptions struct {

	// cache size
	CacheSize int64 `json:"cache_size,omitempty"`

	// data file
	DataFile string `json:"data_file,omitempty"`

	// information list
	InformationList string `json:"information_list,omitempty"`

	// information list separator
	InformationListSeparator string `json:"information_list_separator,omitempty"`

	// patch file
	PatchFile string `json:"patch_file,omitempty"`
}

GlobalWurflOptions global wurfl options

swagger:model GlobalWurflOptions

func (*GlobalWurflOptions) ContextValidate ¶ 

func (m *GlobalWurflOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this global wurfl options based on context it is used

func (GlobalWurflOptions) Diff ¶ added in v5.1.0 

func (s GlobalWurflOptions) Diff(t GlobalWurflOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type GlobalWurflOptions are equal 

var a, b GlobalWurflOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (GlobalWurflOptions) Equal ¶ added in v5.1.0 

func (s GlobalWurflOptions) Equal(t GlobalWurflOptions, opts ...Options) bool

Equal checks if two structs of type GlobalWurflOptions are equal 

var a, b GlobalWurflOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*GlobalWurflOptions) MarshalBinary ¶ 

func (m *GlobalWurflOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*GlobalWurflOptions) UnmarshalBinary ¶ 

func (m *GlobalWurflOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*GlobalWurflOptions) Validate ¶ 

func (m *GlobalWurflOptions) Validate(formats strfmt.Registry) error

Validate validates this global wurfl options

type Group ¶ 

type Group struct {
	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name string `json:"name"`

	// users
	Users string `json:"users,omitempty"`
}

Group Group

HAProxy userlist group ¶

swagger:model group

func (*Group) ContextValidate ¶ 

func (m *Group) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this group based on context it is used

func (Group) Diff ¶ added in v5.1.0 

func (s Group) Diff(t Group, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Group are equal 

var a, b Group
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Group) Equal ¶ added in v5.1.0 

func (s Group) Equal(t Group, opts ...Options) bool

Equal checks if two structs of type Group are equal 

var a, b Group
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Group) MarshalBinary ¶ 

func (m *Group) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Group) UnmarshalBinary ¶ 

func (m *Group) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Group) Validate ¶ 

func (m *Group) Validate(formats strfmt.Registry) error

Validate validates this group

type Groups ¶ 

type Groups []*Group

Groups Groups

HAProxy userlist groups array ¶

swagger:model groups

func (Groups) ContextValidate ¶ 

func (m Groups) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this groups based on the context it is used

func (Groups) Diff ¶ added in v5.1.0 

func (s Groups) Diff(t Groups, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Groups are equal

By default empty maps and slices are equal to nil: 

var a, b Groups
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Groups
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Groups) Equal ¶ added in v5.1.0 

func (s Groups) Equal(t Groups, opts ...Options) bool

Equal checks if two structs of type Groups are equal

By default empty maps and slices are equal to nil: 

var a, b Groups
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Groups
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Groups) Validate ¶ 

func (m Groups) Validate(formats strfmt.Registry) error

Validate validates this groups

type H1CaseAdjust ¶ 

type H1CaseAdjust struct {

	// from
	// Required: true
	From *string `json:"from"`

	// to
	// Required: true
	To *string `json:"to"`
}

H1CaseAdjust h1 case adjust

swagger:model H1CaseAdjust

func (*H1CaseAdjust) ContextValidate ¶ 

func (m *H1CaseAdjust) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this h1 case adjust based on context it is used

func (H1CaseAdjust) Diff ¶ added in v5.1.0 

func (s H1CaseAdjust) Diff(t H1CaseAdjust, opts ...Options) map[string][]interface{}

Diff checks if two structs of type H1CaseAdjust are equal 

var a, b H1CaseAdjust
diff := a.Diff(b)

opts ...Options are ignored in this method

func (H1CaseAdjust) Equal ¶ added in v5.1.0 

func (s H1CaseAdjust) Equal(t H1CaseAdjust, opts ...Options) bool

Equal checks if two structs of type H1CaseAdjust are equal 

var a, b H1CaseAdjust
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*H1CaseAdjust) MarshalBinary ¶ 

func (m *H1CaseAdjust) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*H1CaseAdjust) UnmarshalBinary ¶ 

func (m *H1CaseAdjust) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*H1CaseAdjust) Validate ¶ 

func (m *H1CaseAdjust) Validate(formats strfmt.Registry) error

Validate validates this h1 case adjust

type HTTPAfterResponseRule ¶ 

type HTTPAfterResponseRule struct {
	// acl file
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ACLFile string `json:"acl_file,omitempty"`

	// acl keyfmt
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ACLKeyfmt string `json:"acl_keyfmt,omitempty"`

	// capture id
	CaptureID *int64 `json:"capture_id,omitempty"`

	// capture len
	CaptureLen int64 `json:"capture_len,omitempty"`

	// capture sample
	// Pattern: ^(?:[A-Za-z]+\("([A-Za-z\s]+)"\)|[A-Za-z]+)
	// +kubebuilder:validation:Pattern=`^(?:[A-Za-z]+\("([A-Za-z\s]+)"\)|[A-Za-z]+)`
	CaptureSample string `json:"capture_sample,omitempty"`

	// cond
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond string `json:"cond,omitempty"`

	// cond test
	CondTest string `json:"cond_test,omitempty"`

	// hdr format
	HdrFormat string `json:"hdr_format,omitempty"`

	// hdr match
	HdrMatch string `json:"hdr_match,omitempty"`

	// hdr method
	HdrMethod string `json:"hdr_method,omitempty"`

	// hdr name
	HdrName string `json:"hdr_name,omitempty"`

	// index
	// Required: true
	// +kubebuilder:validation:Optional
	Index *int64 `json:"index"`

	// log level
	// Enum: [emerg alert crit err warning notice info debug silent]
	// +kubebuilder:validation:Enum=emerg;alert;crit;err;warning;notice;info;debug;silent;
	LogLevel string `json:"log_level,omitempty"`

	// map file
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	MapFile string `json:"map_file,omitempty"`

	// map keyfmt
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	MapKeyfmt string `json:"map_keyfmt,omitempty"`

	// map valuefmt
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	MapValuefmt string `json:"map_valuefmt,omitempty"`

	// sc expr
	ScExpr string `json:"sc_expr,omitempty"`

	// sc id
	ScID int64 `json:"sc_id,omitempty"`

	// sc idx
	ScIdx int64 `json:"sc_idx,omitempty"`

	// sc int
	ScInt *int64 `json:"sc_int,omitempty"`

	// status
	// Maximum: 999
	// Minimum: 100
	// +kubebuilder:validation:Maximum=999
	// +kubebuilder:validation:Minimum=100
	Status int64 `json:"status,omitempty"`

	// status reason
	StatusReason string `json:"status_reason,omitempty"`

	// strict mode
	// Enum: [on off]
	// +kubebuilder:validation:Enum=on;off;
	StrictMode string `json:"strict_mode,omitempty"`

	// type
	// Required: true
	// Enum: [add-header allow capture del-acl del-header del-map replace-header replace-value sc-add-gpc sc-inc-gpc sc-inc-gpc0 sc-inc-gpc1 sc-set-gpt sc-set-gpt0 set-header set-log-level set-map set-status set-var set-var-fmt strict-mode unset-var]
	// +kubebuilder:validation:Enum=add-header;allow;capture;del-acl;del-header;del-map;replace-header;replace-value;sc-add-gpc;sc-inc-gpc;sc-inc-gpc0;sc-inc-gpc1;sc-set-gpt;sc-set-gpt0;set-header;set-log-level;set-map;set-status;set-var;set-var-fmt;strict-mode;unset-var;
	Type string `json:"type"`

	// var expr
	VarExpr string `json:"var_expr,omitempty"`

	// var format
	VarFormat string `json:"var_format,omitempty"`

	// var name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	VarName string `json:"var_name,omitempty"`

	// var scope
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	VarScope string `json:"var_scope,omitempty"`
}

HTTPAfterResponseRule HTTP after Response Rule

HAProxy HTTP after response rule configuration (corresponds to http-after-response directives) Example: {"cond":"unless","cond_test":"{ src 192.168.0.0/16 }","hdr_format":"max-age=31536000","hdr_name":"Strict-Transport-Security","index":0,"type":"set-header"}

swagger:model http_after_response_rule

func (*HTTPAfterResponseRule) ContextValidate ¶ 

func (m *HTTPAfterResponseRule) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this http after response rule based on context it is used

func (HTTPAfterResponseRule) Diff ¶ added in v5.1.0 

func (s HTTPAfterResponseRule) Diff(t HTTPAfterResponseRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HTTPAfterResponseRule are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPAfterResponseRule
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPAfterResponseRule
diff := a.Diff(b,Options{
	SkipIndex: true,
})

func (HTTPAfterResponseRule) Equal ¶ added in v5.1.0 

func (s HTTPAfterResponseRule) Equal(t HTTPAfterResponseRule, opts ...Options) bool

Equal checks if two structs of type HTTPAfterResponseRule are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPAfterResponseRule
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPAfterResponseRule
equal := a.Equal(b,Options{
	SkipIndex: true,
})

func (*HTTPAfterResponseRule) MarshalBinary ¶ 

func (m *HTTPAfterResponseRule) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HTTPAfterResponseRule) UnmarshalBinary ¶ 

func (m *HTTPAfterResponseRule) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HTTPAfterResponseRule) Validate ¶ 

func (m *HTTPAfterResponseRule) Validate(formats strfmt.Registry) error

Validate validates this http after response rule

type HTTPAfterResponseRules ¶ 

type HTTPAfterResponseRules []*HTTPAfterResponseRule

HTTPAfterResponseRules HTTP After Response Rules Array

HAProxy HTTP after response rules array (corresponds to http-after-response directives)

swagger:model http_after_response_rules

func (HTTPAfterResponseRules) ContextValidate ¶ 

func (m HTTPAfterResponseRules) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this http after response rules based on the context it is used

func (HTTPAfterResponseRules) Diff ¶ added in v5.1.0 

func (s HTTPAfterResponseRules) Diff(t HTTPAfterResponseRules, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HTTPAfterResponseRules are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPAfterResponseRules
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPAfterResponseRules
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPAfterResponseRules) Equal ¶ added in v5.1.0 

func (s HTTPAfterResponseRules) Equal(t HTTPAfterResponseRules, opts ...Options) bool

Equal checks if two structs of type HTTPAfterResponseRules are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPAfterResponseRules
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPAfterResponseRules
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPAfterResponseRules) Validate ¶ 

func (m HTTPAfterResponseRules) Validate(formats strfmt.Registry) error

Validate validates this http after response rules

type HTTPCheck ¶ 

type HTTPCheck struct {

	// check headers
	CheckHeaders []*ReturnHeader `json:"headers,omitempty"`

	// addr
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Addr string `json:"addr,omitempty"`

	// alpn
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Alpn string `json:"alpn,omitempty"`

	// body
	Body string `json:"body,omitempty"`

	// body log format
	BodyLogFormat string `json:"body_log_format,omitempty"`

	// check comment
	CheckComment string `json:"check_comment,omitempty"`

	// default
	Default bool `json:"default,omitempty"`

	// error status
	// Enum: [L7OKC L7RSP L7STS L6RSP L4CON]
	// +kubebuilder:validation:Enum=L7OKC;L7RSP;L7STS;L6RSP;L4CON;
	ErrorStatus string `json:"error_status,omitempty"`

	// exclamation mark
	ExclamationMark bool `json:"exclamation_mark,omitempty"`

	// index
	// Required: true
	// +kubebuilder:validation:Optional
	Index *int64 `json:"index"`

	// linger
	Linger bool `json:"linger,omitempty"`

	// match
	// Pattern: ^[^\s]+$
	// Enum: [status rstatus hdr fhdr string rstring]
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	// +kubebuilder:validation:Enum=status;rstatus;hdr;fhdr;string;rstring;
	Match string `json:"match,omitempty"`

	// method
	// Enum: [HEAD PUT POST GET TRACE PATCH DELETE CONNECT OPTIONS]
	// +kubebuilder:validation:Enum=HEAD;PUT;POST;GET;TRACE;PATCH;DELETE;CONNECT;OPTIONS;
	Method string `json:"method,omitempty"`

	// min recv
	MinRecv *int64 `json:"min_recv,omitempty"`

	// ok status
	// Enum: [L7OK L7OKC L6OK L4OK]
	// +kubebuilder:validation:Enum=L7OK;L7OKC;L6OK;L4OK;
	OkStatus string `json:"ok_status,omitempty"`

	// on error
	OnError string `json:"on_error,omitempty"`

	// on success
	OnSuccess string `json:"on_success,omitempty"`

	// pattern
	Pattern string `json:"pattern,omitempty"`

	// port
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port *int64 `json:"port,omitempty"`

	// port string
	PortString string `json:"port_string,omitempty"`

	// proto
	Proto string `json:"proto,omitempty"`

	// send proxy
	SendProxy bool `json:"send_proxy,omitempty"`

	// sni
	Sni string `json:"sni,omitempty"`

	// ssl
	Ssl bool `json:"ssl,omitempty"`

	// status code
	StatusCode string `json:"status-code,omitempty"`

	// tout status
	// Enum: [L7TOUT L6TOUT L4TOUT]
	// +kubebuilder:validation:Enum=L7TOUT;L6TOUT;L4TOUT;
	ToutStatus string `json:"tout_status,omitempty"`

	// type
	// Required: true
	// Enum: [comment connect disable-on-404 expect send send-state set-var set-var-fmt unset-var]
	// +kubebuilder:validation:Enum=comment;connect;disable-on-404;expect;send;send-state;set-var;set-var-fmt;unset-var;
	Type string `json:"type"`

	// uri
	URI string `json:"uri,omitempty"`

	// uri log format
	URILogFormat string `json:"uri_log_format,omitempty"`

	// var expr
	VarExpr string `json:"var_expr,omitempty"`

	// var format
	VarFormat string `json:"var_format,omitempty"`

	// var name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	VarName string `json:"var_name,omitempty"`

	// var scope
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	VarScope string `json:"var_scope,omitempty"`

	// version
	Version string `json:"version,omitempty"`

	// via socks4
	ViaSocks4 bool `json:"via_socks4,omitempty"`
}

HTTPCheck HTTP Check

swagger:model http_check

func (*HTTPCheck) ContextValidate ¶ 

func (m *HTTPCheck) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this http check based on the context it is used

func (HTTPCheck) Diff ¶ added in v5.1.0 

func (s HTTPCheck) Diff(t HTTPCheck, opts ...Options) map[string][]interface{}
	SkipIndex: true,
})

func (HTTPCheck) Equal ¶ added in v5.1.0 

func (s HTTPCheck) Equal(t HTTPCheck, opts ...Options) bool
	SkipIndex: true,
})

func (*HTTPCheck) MarshalBinary ¶ 

func (m *HTTPCheck) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HTTPCheck) UnmarshalBinary ¶ 

func (m *HTTPCheck) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HTTPCheck) Validate ¶ 

func (m *HTTPCheck) Validate(formats strfmt.Registry) error

Validate validates this http check

type HTTPChecks ¶ 

type HTTPChecks []*HTTPCheck

HTTPChecks HTTP Checks Array

swagger:model http_checks

func (HTTPChecks) ContextValidate ¶ 

func (m HTTPChecks) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this http checks based on the context it is used

func (HTTPChecks) Diff ¶ added in v5.1.0 

func (s HTTPChecks) Diff(t HTTPChecks, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HTTPChecks are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPChecks
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPChecks
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPChecks) Equal ¶ added in v5.1.0 

func (s HTTPChecks) Equal(t HTTPChecks, opts ...Options) bool

Equal checks if two structs of type HTTPChecks are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPChecks
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPChecks
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPChecks) Validate ¶ 

func (m HTTPChecks) Validate(formats strfmt.Registry) error

Validate validates this http checks

type HTTPErrorRule ¶ 

type HTTPErrorRule struct {

	// return headers
	ReturnHeaders []*ReturnHeader `json:"return_hdrs,omitempty"`

	// index
	// Required: true
	// +kubebuilder:validation:Optional
	Index *int64 `json:"index"`

	// return content
	ReturnContent string `json:"return_content,omitempty"`

	// return content format
	// Enum: [default-errorfiles errorfile errorfiles file lf-file string lf-string]
	// +kubebuilder:validation:Enum=default-errorfiles;errorfile;errorfiles;file;lf-file;string;lf-string;
	ReturnContentFormat string `json:"return_content_format,omitempty"`

	// return content type
	ReturnContentType *string `json:"return_content_type,omitempty"`

	// status
	// Required: true
	// Enum: [200 400 401 403 404 405 407 408 410 413 425 429 500 501 502 503 504]
	// +kubebuilder:validation:Enum=200;400;401;403;404;405;407;408;410;413;425;429;500;501;502;503;504;
	Status int64 `json:"status"`

	// type
	// Required: true
	// Enum: [status]
	// +kubebuilder:validation:Enum=status;
	Type string `json:"type"`
}

HTTPErrorRule HTTP Error Rule

HAProxy HTTP error rule configuration (corresponds to http-error directives) Example: {"index":0,"status":425,"type":"status"}

swagger:model http_error_rule

func (*HTTPErrorRule) ContextValidate ¶ 

func (m *HTTPErrorRule) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this http error rule based on the context it is used

func (HTTPErrorRule) Diff ¶ added in v5.1.0 

func (s HTTPErrorRule) Diff(t HTTPErrorRule, opts ...Options) map[string][]interface{}
	SkipIndex: true,
})

func (HTTPErrorRule) Equal ¶ added in v5.1.0 

func (s HTTPErrorRule) Equal(t HTTPErrorRule, opts ...Options) bool
	SkipIndex: true,
})

func (*HTTPErrorRule) MarshalBinary ¶ 

func (m *HTTPErrorRule) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HTTPErrorRule) UnmarshalBinary ¶ 

func (m *HTTPErrorRule) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HTTPErrorRule) Validate ¶ 

func (m *HTTPErrorRule) Validate(formats strfmt.Registry) error

Validate validates this http error rule

type HTTPErrorRules ¶ 

type HTTPErrorRules []*HTTPErrorRule

HTTPErrorRules HTTP Error Rules Array

HAProxy HTTP error rules array (corresponds to http-error directives)

swagger:model http_error_rules

func (HTTPErrorRules) ContextValidate ¶ 

func (m HTTPErrorRules) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this http error rules based on the context it is used

func (HTTPErrorRules) Diff ¶ added in v5.1.0 

func (s HTTPErrorRules) Diff(t HTTPErrorRules, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HTTPErrorRules are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPErrorRules
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPErrorRules
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPErrorRules) Equal ¶ added in v5.1.0 

func (s HTTPErrorRules) Equal(t HTTPErrorRules, opts ...Options) bool

Equal checks if two structs of type HTTPErrorRules are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPErrorRules
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPErrorRules
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPErrorRules) Validate ¶ 

func (m HTTPErrorRules) Validate(formats strfmt.Registry) error

Validate validates this http error rules

type HTTPErrorsSection ¶ 

type HTTPErrorsSection struct {

	// error files
	// Required: true
	ErrorFiles []*Errorfile `json:"error_files"`

	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_]+$`
	Name string `json:"name"`
}

HTTPErrorsSection http-errors section

A globally declared group of HTTP errors Example: {"error_files":[{"code":400,"name":"/etc/haproxy/errorfiles/site1/400.http"},{"code":404,"name":"/etc/haproxy/errorfiles/site1/404.http"}],"name":"website-1"}

swagger:model http_errors_section

func (*HTTPErrorsSection) ContextValidate ¶ 

func (m *HTTPErrorsSection) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this http errors section based on the context it is used

func (HTTPErrorsSection) Diff ¶ added in v5.1.0 

func (s HTTPErrorsSection) Diff(t HTTPErrorsSection, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HTTPErrorsSection are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPErrorsSection
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPErrorsSection
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPErrorsSection) Equal ¶ added in v5.1.0 

func (s HTTPErrorsSection) Equal(t HTTPErrorsSection, opts ...Options) bool

Equal checks if two structs of type HTTPErrorsSection are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPErrorsSection
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPErrorsSection
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*HTTPErrorsSection) MarshalBinary ¶ 

func (m *HTTPErrorsSection) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HTTPErrorsSection) UnmarshalBinary ¶ 

func (m *HTTPErrorsSection) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HTTPErrorsSection) Validate ¶ 

func (m *HTTPErrorsSection) Validate(formats strfmt.Registry) error

Validate validates this http errors section

type HTTPErrorsSections ¶ 

type HTTPErrorsSections []*HTTPErrorsSection

HTTPErrorsSections http-errors sections

An array of HAProxy http-error sections ¶

swagger:model http_errors_sections

func (HTTPErrorsSections) ContextValidate ¶ 

func (m HTTPErrorsSections) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this http errors sections based on the context it is used

func (HTTPErrorsSections) Diff ¶ added in v5.1.0 

func (s HTTPErrorsSections) Diff(t HTTPErrorsSections, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HTTPErrorsSections are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPErrorsSections
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPErrorsSections
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPErrorsSections) Equal ¶ added in v5.1.0 

func (s HTTPErrorsSections) Equal(t HTTPErrorsSections, opts ...Options) bool

Equal checks if two structs of type HTTPErrorsSections are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPErrorsSections
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPErrorsSections
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPErrorsSections) Validate ¶ 

func (m HTTPErrorsSections) Validate(formats strfmt.Registry) error

Validate validates this http errors sections

type HTTPRequestRule ¶ 

type HTTPRequestRule struct {

	// return headers
	ReturnHeaders []*ReturnHeader `json:"return_hdrs,omitempty"`

	// acl file
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ACLFile string `json:"acl_file,omitempty"`

	// acl keyfmt
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ACLKeyfmt string `json:"acl_keyfmt,omitempty"`

	// auth realm
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	AuthRealm string `json:"auth_realm,omitempty"`

	// bandwidth limit limit
	BandwidthLimitLimit string `json:"bandwidth_limit_limit,omitempty"`

	// bandwidth limit name
	BandwidthLimitName string `json:"bandwidth_limit_name,omitempty"`

	// bandwidth limit period
	BandwidthLimitPeriod string `json:"bandwidth_limit_period,omitempty"`

	// cache name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	CacheName string `json:"cache_name,omitempty"`

	// capture id
	CaptureID *int64 `json:"capture_id,omitempty"`

	// capture len
	CaptureLen int64 `json:"capture_len,omitempty"`

	// capture sample
	// Pattern: ^(?:[A-Za-z]+\("([A-Za-z\s]+)"\)|[A-Za-z]+)
	// +kubebuilder:validation:Pattern=`^(?:[A-Za-z]+\("([A-Za-z\s]+)"\)|[A-Za-z]+)`
	CaptureSample string `json:"capture_sample,omitempty"`

	// cond
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond string `json:"cond,omitempty"`

	// cond test
	CondTest string `json:"cond_test,omitempty"`

	// deny status
	// Maximum: 599
	// Minimum: 200
	// +kubebuilder:validation:Maximum=599
	// +kubebuilder:validation:Minimum=200
	DenyStatus *int64 `json:"deny_status,omitempty"`

	// expr
	Expr string `json:"expr,omitempty"`

	// hdr format
	HdrFormat string `json:"hdr_format,omitempty"`

	// hdr match
	HdrMatch string `json:"hdr_match,omitempty"`

	// hdr method
	HdrMethod string `json:"hdr_method,omitempty"`

	// hdr name
	HdrName string `json:"hdr_name,omitempty"`

	// hint format
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	HintFormat string `json:"hint_format,omitempty"`

	// hint name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	HintName string `json:"hint_name,omitempty"`

	// index
	// Required: true
	// +kubebuilder:validation:Optional
	Index *int64 `json:"index"`

	// log level
	// Enum: [emerg alert crit err warning notice info debug silent]
	// +kubebuilder:validation:Enum=emerg;alert;crit;err;warning;notice;info;debug;silent;
	LogLevel string `json:"log_level,omitempty"`

	// lua action
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	LuaAction string `json:"lua_action,omitempty"`

	// lua params
	LuaParams string `json:"lua_params,omitempty"`

	// map file
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	MapFile string `json:"map_file,omitempty"`

	// map keyfmt
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	MapKeyfmt string `json:"map_keyfmt,omitempty"`

	// map valuefmt
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	MapValuefmt string `json:"map_valuefmt,omitempty"`

	// mark value
	// Pattern: ^(0x[0-9A-Fa-f]+|[0-9]+)$
	// +kubebuilder:validation:Pattern=`^(0x[0-9A-Fa-f]+|[0-9]+)$`
	MarkValue string `json:"mark_value,omitempty"`

	// method fmt
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	MethodFmt string `json:"method_fmt,omitempty"`

	// nice value
	// Maximum: 1024
	// Minimum: -1024
	// +kubebuilder:validation:Maximum=1024
	// +kubebuilder:validation:Minimum=-1024
	NiceValue int64 `json:"nice_value,omitempty"`

	// normalizer
	// Enum: [fragment-encode fragment-strip path-merge-slashes path-strip-dot path-strip-dotdot percent-decode-unreserved percent-to-uppercase query-sort-by-name]
	// +kubebuilder:validation:Enum=fragment-encode;fragment-strip;path-merge-slashes;path-strip-dot;path-strip-dotdot;percent-decode-unreserved;percent-to-uppercase;query-sort-by-name;
	Normalizer string `json:"normalizer,omitempty"`

	// normalizer full
	NormalizerFull bool `json:"normalizer_full,omitempty"`

	// normalizer strict
	NormalizerStrict bool `json:"normalizer_strict,omitempty"`

	// path fmt
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	PathFmt string `json:"path_fmt,omitempty"`

	// path match
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	PathMatch string `json:"path_match,omitempty"`

	// protocol
	// Enum: [ipv4 ipv6]
	// +kubebuilder:validation:Enum=ipv4;ipv6;
	Protocol string `json:"protocol,omitempty"`

	// query fmt
	QueryFmt string `json:"query-fmt,omitempty"`

	// redir code
	// Enum: [301 302 303 307 308]
	// +kubebuilder:validation:Enum=301;302;303;307;308;
	RedirCode *int64 `json:"redir_code,omitempty"`

	// redir option
	RedirOption string `json:"redir_option,omitempty"`

	// redir type
	// Enum: [location prefix scheme]
	// +kubebuilder:validation:Enum=location;prefix;scheme;
	RedirType string `json:"redir_type,omitempty"`

	// redir value
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	RedirValue string `json:"redir_value,omitempty"`

	// resolvers
	Resolvers string `json:"resolvers,omitempty"`

	// return content
	ReturnContent string `json:"return_content,omitempty"`

	// return content format
	// Enum: [default-errorfiles errorfile errorfiles file lf-file string lf-string]
	// +kubebuilder:validation:Enum=default-errorfiles;errorfile;errorfiles;file;lf-file;string;lf-string;
	ReturnContentFormat string `json:"return_content_format,omitempty"`

	// return content type
	ReturnContentType *string `json:"return_content_type,omitempty"`

	// return status code
	// Maximum: 599
	// Minimum: 200
	// +kubebuilder:validation:Maximum=599
	// +kubebuilder:validation:Minimum=200
	ReturnStatusCode *int64 `json:"return_status_code,omitempty"`

	// rst ttl
	RstTTL int64 `json:"rst_ttl,omitempty"`

	// sc expr
	ScExpr string `json:"sc_expr,omitempty"`

	// sc id
	ScID int64 `json:"sc_id,omitempty"`

	// sc idx
	ScIdx int64 `json:"sc_idx,omitempty"`

	// sc int
	ScInt *int64 `json:"sc_int,omitempty"`

	// service name
	ServiceName string `json:"service_name,omitempty"`

	// spoe engine
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	SpoeEngine string `json:"spoe_engine,omitempty"`

	// spoe group
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	SpoeGroup string `json:"spoe_group,omitempty"`

	// strict mode
	// Enum: [on off]
	// +kubebuilder:validation:Enum=on;off;
	StrictMode string `json:"strict_mode,omitempty"`

	// timeout
	Timeout string `json:"timeout,omitempty"`

	// timeout type
	// Enum: [server tunnel client]
	// +kubebuilder:validation:Enum=server;tunnel;client;
	TimeoutType string `json:"timeout_type,omitempty"`

	// tos value
	// Pattern: ^(0x[0-9A-Fa-f]+|[0-9]+)$
	// +kubebuilder:validation:Pattern=`^(0x[0-9A-Fa-f]+|[0-9]+)$`
	TosValue string `json:"tos_value,omitempty"`

	// track sc0 key
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackSc0Key string `json:"track-sc0-key,omitempty"`

	// track sc0 table
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackSc0Table string `json:"track-sc0-table,omitempty"`

	// track sc1 key
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackSc1Key string `json:"track-sc1-key,omitempty"`

	// track sc1 table
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackSc1Table string `json:"track-sc1-table,omitempty"`

	// track sc2 key
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackSc2Key string `json:"track-sc2-key,omitempty"`

	// track sc2 table
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackSc2Table string `json:"track-sc2-table,omitempty"`

	// track sc key
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackScKey string `json:"track_sc_key,omitempty"`

	// track sc stick counter
	TrackScStickCounter *int64 `json:"track_sc_stick_counter,omitempty"`

	// track sc table
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackScTable string `json:"track_sc_table,omitempty"`

	// type
	// Required: true
	// Enum: [add-acl add-header allow auth cache-use capture del-acl del-header del-map deny disable-l7-retry do-resolve early-hint lua normalize-uri redirect reject replace-header replace-path replace-pathq replace-uri replace-value return sc-add-gpc sc-inc-gpc sc-inc-gpc0 sc-inc-gpc1 sc-set-gpt sc-set-gpt0 send-spoe-group set-dst set-dst-port set-header set-log-level set-map set-mark set-method set-nice set-path set-pathq set-priority-class set-priority-offset set-query set-src set-src-port set-timeout set-tos set-uri set-var silent-drop strict-mode tarpit track-sc0 track-sc1 track-sc2 track-sc unset-var use-service wait-for-body wait-for-handshake set-bandwidth-limit]
	// +kubebuilder:validation:Enum=add-acl;add-header;allow;auth;cache-use;capture;del-acl;del-header;del-map;deny;disable-l7-retry;do-resolve;early-hint;lua;normalize-uri;redirect;reject;replace-header;replace-path;replace-pathq;replace-uri;replace-value;return;sc-add-gpc;sc-inc-gpc;sc-inc-gpc0;sc-inc-gpc1;sc-set-gpt;sc-set-gpt0;send-spoe-group;set-dst;set-dst-port;set-header;set-log-level;set-map;set-mark;set-method;set-nice;set-path;set-pathq;set-priority-class;set-priority-offset;set-query;set-src;set-src-port;set-timeout;set-tos;set-uri;set-var;silent-drop;strict-mode;tarpit;track-sc0;track-sc1;track-sc2;track-sc;unset-var;use-service;wait-for-body;wait-for-handshake;set-bandwidth-limit;
	Type string `json:"type"`

	// uri fmt
	URIFmt string `json:"uri-fmt,omitempty"`

	// uri match
	URIMatch string `json:"uri-match,omitempty"`

	// var expr
	VarExpr string `json:"var_expr,omitempty"`

	// var format
	VarFormat string `json:"var_format,omitempty"`

	// var name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	VarName string `json:"var_name,omitempty"`

	// var scope
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	VarScope string `json:"var_scope,omitempty"`

	// wait at least
	WaitAtLeast *int64 `json:"wait_at_least,omitempty"`

	// wait time
	WaitTime *int64 `json:"wait_time,omitempty"`
}

HTTPRequestRule HTTP Request Rule

HAProxy HTTP request rule configuration (corresponds to http-request directives) Example: {"cond":"unless","cond_test":"{ src 192.168.0.0/16 }","hdr_format":"%T","hdr_name":"X-Haproxy-Current-Date","index":0,"type":"add-header"}

swagger:model http_request_rule

func (*HTTPRequestRule) ContextValidate ¶ 

func (m *HTTPRequestRule) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this http request rule based on the context it is used

func (HTTPRequestRule) Diff ¶ added in v5.1.0 

func (s HTTPRequestRule) Diff(t HTTPRequestRule, opts ...Options) map[string][]interface{}
	SkipIndex: true,
})

func (HTTPRequestRule) Equal ¶ added in v5.1.0 

func (s HTTPRequestRule) Equal(t HTTPRequestRule, opts ...Options) bool
	SkipIndex: true,
})

func (*HTTPRequestRule) MarshalBinary ¶ 

func (m *HTTPRequestRule) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HTTPRequestRule) UnmarshalBinary ¶ 

func (m *HTTPRequestRule) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HTTPRequestRule) Validate ¶ 

func (m *HTTPRequestRule) Validate(formats strfmt.Registry) error

Validate validates this http request rule

type HTTPRequestRules ¶ 

type HTTPRequestRules []*HTTPRequestRule

HTTPRequestRules HTTP Request Rules Array

HAProxy HTTP request rules array (corresponds to http-request directives)

swagger:model http_request_rules

func (HTTPRequestRules) ContextValidate ¶ 

func (m HTTPRequestRules) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this http request rules based on the context it is used

func (HTTPRequestRules) Diff ¶ added in v5.1.0 

func (s HTTPRequestRules) Diff(t HTTPRequestRules, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HTTPRequestRules are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPRequestRules
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPRequestRules
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPRequestRules) Equal ¶ added in v5.1.0 

func (s HTTPRequestRules) Equal(t HTTPRequestRules, opts ...Options) bool

Equal checks if two structs of type HTTPRequestRules are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPRequestRules
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPRequestRules
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPRequestRules) Validate ¶ 

func (m HTTPRequestRules) Validate(formats strfmt.Registry) error

Validate validates this http request rules

type HTTPResponseRule ¶ 

type HTTPResponseRule struct {

	// return headers
	ReturnHeaders []*ReturnHeader `json:"return_hdrs,omitempty"`

	// acl file
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ACLFile string `json:"acl_file,omitempty"`

	// acl keyfmt
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ACLKeyfmt string `json:"acl_keyfmt,omitempty"`

	// bandwidth limit limit
	BandwidthLimitLimit string `json:"bandwidth_limit_limit,omitempty"`

	// bandwidth limit name
	BandwidthLimitName string `json:"bandwidth_limit_name,omitempty"`

	// bandwidth limit period
	BandwidthLimitPeriod string `json:"bandwidth_limit_period,omitempty"`

	// cache name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	CacheName string `json:"cache_name,omitempty"`

	// capture id
	CaptureID *int64 `json:"capture_id,omitempty"`

	// capture sample
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	CaptureSample string `json:"capture_sample,omitempty"`

	// cond
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond string `json:"cond,omitempty"`

	// cond test
	CondTest string `json:"cond_test,omitempty"`

	// deny status
	// Maximum: 599
	// Minimum: 200
	// +kubebuilder:validation:Maximum=599
	// +kubebuilder:validation:Minimum=200
	DenyStatus *int64 `json:"deny_status,omitempty"`

	// hdr format
	HdrFormat string `json:"hdr_format,omitempty"`

	// hdr match
	HdrMatch string `json:"hdr_match,omitempty"`

	// hdr method
	HdrMethod string `json:"hdr_method,omitempty"`

	// hdr name
	HdrName string `json:"hdr_name,omitempty"`

	// index
	// Required: true
	// +kubebuilder:validation:Optional
	Index *int64 `json:"index"`

	// log level
	// Enum: [emerg alert crit err warning notice info debug silent]
	// +kubebuilder:validation:Enum=emerg;alert;crit;err;warning;notice;info;debug;silent;
	LogLevel string `json:"log_level,omitempty"`

	// lua action
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	LuaAction string `json:"lua_action,omitempty"`

	// lua params
	LuaParams string `json:"lua_params,omitempty"`

	// map file
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	MapFile string `json:"map_file,omitempty"`

	// map keyfmt
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	MapKeyfmt string `json:"map_keyfmt,omitempty"`

	// map valuefmt
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	MapValuefmt string `json:"map_valuefmt,omitempty"`

	// mark value
	// Pattern: ^(0x[0-9A-Fa-f]+|[0-9]+)$
	// +kubebuilder:validation:Pattern=`^(0x[0-9A-Fa-f]+|[0-9]+)$`
	MarkValue string `json:"mark_value,omitempty"`

	// nice value
	// Maximum: 1024
	// Minimum: -1024
	// +kubebuilder:validation:Maximum=1024
	// +kubebuilder:validation:Minimum=-1024
	NiceValue int64 `json:"nice_value,omitempty"`

	// redir code
	// Enum: [301 302 303 307 308]
	// +kubebuilder:validation:Enum=301;302;303;307;308;
	RedirCode *int64 `json:"redir_code,omitempty"`

	// redir option
	RedirOption string `json:"redir_option,omitempty"`

	// redir type
	// Enum: [location prefix scheme]
	// +kubebuilder:validation:Enum=location;prefix;scheme;
	RedirType string `json:"redir_type,omitempty"`

	// redir value
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	RedirValue string `json:"redir_value,omitempty"`

	// return content
	ReturnContent string `json:"return_content,omitempty"`

	// return content format
	// Enum: [default-errorfiles errorfile errorfiles file lf-file string lf-string]
	// +kubebuilder:validation:Enum=default-errorfiles;errorfile;errorfiles;file;lf-file;string;lf-string;
	ReturnContentFormat string `json:"return_content_format,omitempty"`

	// return content type
	ReturnContentType *string `json:"return_content_type,omitempty"`

	// return status code
	// Maximum: 599
	// Minimum: 200
	// +kubebuilder:validation:Maximum=599
	// +kubebuilder:validation:Minimum=200
	ReturnStatusCode *int64 `json:"return_status_code,omitempty"`

	// rst ttl
	RstTTL int64 `json:"rst_ttl,omitempty"`

	// sc expr
	ScExpr string `json:"sc_expr,omitempty"`

	// sc id
	ScID int64 `json:"sc_id,omitempty"`

	// sc idx
	ScIdx int64 `json:"sc_idx,omitempty"`

	// sc int
	ScInt *int64 `json:"sc_int,omitempty"`

	// spoe engine
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	SpoeEngine string `json:"spoe_engine,omitempty"`

	// spoe group
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	SpoeGroup string `json:"spoe_group,omitempty"`

	// status
	// Maximum: 999
	// Minimum: 100
	// +kubebuilder:validation:Maximum=999
	// +kubebuilder:validation:Minimum=100
	Status int64 `json:"status,omitempty"`

	// status reason
	StatusReason string `json:"status_reason,omitempty"`

	// strict mode
	// Enum: [on off]
	// +kubebuilder:validation:Enum=on;off;
	StrictMode string `json:"strict_mode,omitempty"`

	// timeout
	Timeout string `json:"timeout,omitempty"`

	// timeout type
	// Enum: [server tunnel client]
	// +kubebuilder:validation:Enum=server;tunnel;client;
	TimeoutType string `json:"timeout_type,omitempty"`

	// tos value
	// Pattern: ^(0x[0-9A-Fa-f]+|[0-9]+)$
	// +kubebuilder:validation:Pattern=`^(0x[0-9A-Fa-f]+|[0-9]+)$`
	TosValue string `json:"tos_value,omitempty"`

	// track sc0 key
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackSc0Key string `json:"track-sc0-key,omitempty"`

	// track sc0 table
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackSc0Table string `json:"track-sc0-table,omitempty"`

	// track sc1 key
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackSc1Key string `json:"track-sc1-key,omitempty"`

	// track sc1 table
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackSc1Table string `json:"track-sc1-table,omitempty"`

	// track sc2 key
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackSc2Key string `json:"track-sc2-key,omitempty"`

	// track sc2 table
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackSc2Table string `json:"track-sc2-table,omitempty"`

	// track sc key
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackScKey string `json:"track_sc_key,omitempty"`

	// track sc stick counter
	TrackScStickCounter *int64 `json:"track_sc_stick_counter,omitempty"`

	// track sc table
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TrackScTable string `json:"track_sc_table,omitempty"`

	// type
	// Required: true
	// Enum: [add-acl add-header allow cache-store capture del-acl del-header del-map deny lua redirect replace-header replace-value return sc-add-gpc sc-inc-gpc sc-inc-gpc0 sc-inc-gpc1 sc-set-gpt sc-set-gpt0 send-spoe-group set-header set-log-level set-map set-mark set-nice set-status set-timeout set-tos set-var set-var-fmt silent-drop strict-mode track-sc0 track-sc1 track-sc2 track-sc unset-var wait-for-body set-bandwidth-limit]
	// +kubebuilder:validation:Enum=add-acl;add-header;allow;cache-store;capture;del-acl;del-header;del-map;deny;lua;redirect;replace-header;replace-value;return;sc-add-gpc;sc-inc-gpc;sc-inc-gpc0;sc-inc-gpc1;sc-set-gpt;sc-set-gpt0;send-spoe-group;set-header;set-log-level;set-map;set-mark;set-nice;set-status;set-timeout;set-tos;set-var;set-var-fmt;silent-drop;strict-mode;track-sc0;track-sc1;track-sc2;track-sc;unset-var;wait-for-body;set-bandwidth-limit;
	Type string `json:"type"`

	// var expr
	VarExpr string `json:"var_expr,omitempty"`

	// var format
	VarFormat string `json:"var_format,omitempty"`

	// var name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	VarName string `json:"var_name,omitempty"`

	// var scope
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	VarScope string `json:"var_scope,omitempty"`

	// wait at least
	WaitAtLeast *int64 `json:"wait_at_least,omitempty"`

	// wait time
	WaitTime *int64 `json:"wait_time,omitempty"`
}

HTTPResponseRule HTTP Response Rule

HAProxy HTTP response rule configuration (corresponds to http-response directives) Example: {"cond":"unless","cond_test":"{ src 192.168.0.0/16 }","hdr_format":"%T","hdr_name":"X-Haproxy-Current-Date","index":0,"type":"add-header"}

swagger:model http_response_rule

func (*HTTPResponseRule) ContextValidate ¶ 

func (m *HTTPResponseRule) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this http response rule based on the context it is used

func (HTTPResponseRule) Diff ¶ added in v5.1.0 

func (s HTTPResponseRule) Diff(t HTTPResponseRule, opts ...Options) map[string][]interface{}
	SkipIndex: true,
})

func (HTTPResponseRule) Equal ¶ added in v5.1.0 

func (s HTTPResponseRule) Equal(t HTTPResponseRule, opts ...Options) bool
	SkipIndex: true,
})

func (*HTTPResponseRule) MarshalBinary ¶ 

func (m *HTTPResponseRule) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HTTPResponseRule) UnmarshalBinary ¶ 

func (m *HTTPResponseRule) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HTTPResponseRule) Validate ¶ 

func (m *HTTPResponseRule) Validate(formats strfmt.Registry) error

Validate validates this http response rule

type HTTPResponseRules ¶ 

type HTTPResponseRules []*HTTPResponseRule

HTTPResponseRules HTTP Response Rules Array

HAProxy HTTP response rules array (corresponds to http-response directives)

swagger:model http_response_rules

func (HTTPResponseRules) ContextValidate ¶ 

func (m HTTPResponseRules) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this http response rules based on the context it is used

func (HTTPResponseRules) Diff ¶ added in v5.1.0 

func (s HTTPResponseRules) Diff(t HTTPResponseRules, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HTTPResponseRules are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPResponseRules
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPResponseRules
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPResponseRules) Equal ¶ added in v5.1.0 

func (s HTTPResponseRules) Equal(t HTTPResponseRules, opts ...Options) bool

Equal checks if two structs of type HTTPResponseRules are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPResponseRules
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPResponseRules
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPResponseRules) Validate ¶ 

func (m HTTPResponseRules) Validate(formats strfmt.Registry) error

Validate validates this http response rules

type HashType ¶ 

type HashType struct {
	// function
	// Enum: [sdbm djb2 wt6 crc32 none]
	// +kubebuilder:validation:Enum=sdbm;djb2;wt6;crc32;none;
	Function string `json:"function,omitempty"`

	// method
	// Enum: [map-based consistent]
	// +kubebuilder:validation:Enum=map-based;consistent;
	Method string `json:"method,omitempty"`

	// modifier
	// Enum: [avalanche]
	// +kubebuilder:validation:Enum=avalanche;
	Modifier string `json:"modifier,omitempty"`
}

HashType hash type

swagger:model hash_type

func (*HashType) ContextValidate ¶ 

func (m *HashType) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hash type based on context it is used

func (HashType) Diff ¶ added in v5.1.0 

func (s HashType) Diff(t HashType, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HashType are equal 

var a, b HashType
diff := a.Diff(b)

opts ...Options are ignored in this method

func (HashType) Equal ¶ added in v5.1.0 

func (s HashType) Equal(t HashType, opts ...Options) bool

Equal checks if two structs of type HashType are equal 

var a, b HashType
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*HashType) MarshalBinary ¶ 

func (m *HashType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashType) UnmarshalBinary ¶ 

func (m *HashType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashType) Validate ¶ 

func (m *HashType) Validate(formats strfmt.Registry) error

Validate validates this hash type

type Health ¶ 

type Health struct {
	// haproxy
	// Enum: [up down unknown]
	// +kubebuilder:validation:Enum=up;down;unknown;
	Haproxy string `json:"haproxy,omitempty"`
}

Health health

swagger:model health

func (*Health) ContextValidate ¶ 

func (m *Health) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this health based on context it is used

func (Health) Diff ¶ added in v5.1.0 

func (s Health) Diff(t Health, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Health are equal 

var a, b Health
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Health) Equal ¶ added in v5.1.0 

func (s Health) Equal(t Health, opts ...Options) bool

Equal checks if two structs of type Health are equal 

var a, b Health
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Health) MarshalBinary ¶ 

func (m *Health) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Health) UnmarshalBinary ¶ 

func (m *Health) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Health) Validate ¶ 

func (m *Health) Validate(formats strfmt.Registry) error

Validate validates this health

type HttpchkParams ¶ 

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

	// uri
	// Pattern: ^[^ ]*$
	// +kubebuilder:validation:Pattern=`^[^ ]*$`
	URI string `json:"uri,omitempty"`

	// version
	Version string `json:"version,omitempty"`
}

HttpchkParams httpchk params

swagger:model httpchk_params

func (*HttpchkParams) ContextValidate ¶ 

func (m *HttpchkParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this httpchk params based on context it is used

func (HttpchkParams) Diff ¶ added in v5.1.0 

func (s HttpchkParams) Diff(t HttpchkParams, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HttpchkParams are equal 

var a, b HttpchkParams
diff := a.Diff(b)

opts ...Options are ignored in this method

func (HttpchkParams) Equal ¶ added in v5.1.0 

func (s HttpchkParams) Equal(t HttpchkParams, opts ...Options) bool

Equal checks if two structs of type HttpchkParams are equal 

var a, b HttpchkParams
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*HttpchkParams) MarshalBinary ¶ 

func (m *HttpchkParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HttpchkParams) UnmarshalBinary ¶ 

func (m *HttpchkParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HttpchkParams) Validate ¶ 

func (m *HttpchkParams) Validate(formats strfmt.Registry) error

Validate validates this httpchk params

type IgnorePersist ¶ added in v5.0.7 

type IgnorePersist struct {
	// cond
	// Required: true
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond *string `json:"cond"`

	// cond test
	// Required: true
	CondTest *string `json:"cond_test"`
}

IgnorePersist ignore persist

swagger:model IgnorePersist

func (*IgnorePersist) ContextValidate ¶ added in v5.0.7 

func (m *IgnorePersist) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this ignore persist based on context it is used

func (IgnorePersist) Diff ¶ added in v5.1.6 

func (s IgnorePersist) Diff(t IgnorePersist, opts ...Options) map[string][]interface{}

Diff checks if two structs of type IgnorePersist are equal 

var a, b IgnorePersist
diff := a.Diff(b)

opts ...Options are ignored in this method

func (IgnorePersist) Equal ¶ added in v5.1.6 

func (s IgnorePersist) Equal(t IgnorePersist, opts ...Options) bool

Equal checks if two structs of type IgnorePersist are equal 

var a, b IgnorePersist
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*IgnorePersist) MarshalBinary ¶ added in v5.0.7 

func (m *IgnorePersist) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IgnorePersist) UnmarshalBinary ¶ added in v5.0.7 

func (m *IgnorePersist) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IgnorePersist) Validate ¶ added in v5.0.7 

func (m *IgnorePersist) Validate(formats strfmt.Registry) error

Validate validates this ignore persist

type Info ¶ 

type Info struct {

	// api
	API *InfoAPI `json:"api,omitempty"`

	// system
	System *InfoSystem `json:"system,omitempty"`
}

Info Information

General API, OS and hardware information Example: {"api":{"build_date":"2019-08-21T17:31:56.000Z","version":"v1.2.1 45a3288.dev"},"system":{"cpu_info":{"model":"Intel(R) Core(TM) i7-7500U CPU @ 2.70GHz","num_cpus":4},"hostname":"test","mem_info":{"dataplaneapi_memory":44755536,"free_memory":5790642176,"total_memory":16681517056},"os_string":"Linux 4.15.0-58-generic #64-Ubuntu SMP Tue Aug 6 11:12:41 UTC 2019","time":1566401525,"uptime":87340}}

swagger:model info

func (*Info) ContextValidate ¶ 

func (m *Info) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this info based on the context it is used

func (Info) Diff ¶ added in v5.1.0 

func (s Info) Diff(t Info, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Info are equal

By default empty maps and slices are equal to nil: 

var a, b Info
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Info
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Info) Equal ¶ added in v5.1.0 

func (s Info) Equal(t Info, opts ...Options) bool

Equal checks if two structs of type Info are equal

By default empty maps and slices are equal to nil: 

var a, b Info
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Info
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Info) MarshalBinary ¶ 

func (m *Info) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Info) UnmarshalBinary ¶ 

func (m *Info) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Info) Validate ¶ 

func (m *Info) Validate(formats strfmt.Registry) error

Validate validates this info

type InfoAPI ¶ 

type InfoAPI struct {
	// HAProxy Dataplane API build date
	// Format: date-time
	// +kubebuilder:validation:Format=date-time
	BuildDate strfmt.DateTime `json:"build_date,omitempty"`

	// HAProxy Dataplane API version string
	Version string `json:"version,omitempty"`
}

InfoAPI info API

swagger:model InfoAPI

func (*InfoAPI) ContextValidate ¶ 

func (m *InfoAPI) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this info API based on context it is used

func (InfoAPI) Diff ¶ added in v5.1.0 

func (s InfoAPI) Diff(t InfoAPI, opts ...Options) map[string][]interface{}

Diff checks if two structs of type InfoAPI are equal 

var a, b InfoAPI
diff := a.Diff(b)

opts ...Options are ignored in this method

func (InfoAPI) Equal ¶ added in v5.1.0 

func (s InfoAPI) Equal(t InfoAPI, opts ...Options) bool

Equal checks if two structs of type InfoAPI are equal 

var a, b InfoAPI
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*InfoAPI) MarshalBinary ¶ 

func (m *InfoAPI) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InfoAPI) UnmarshalBinary ¶ 

func (m *InfoAPI) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InfoAPI) Validate ¶ 

func (m *InfoAPI) Validate(formats strfmt.Registry) error

Validate validates this info API

type InfoSystem ¶ 

type InfoSystem struct {

	// cpu info
	CPUInfo *InfoSystemCPUInfo `json:"cpu_info,omitempty"`

	// Hostname where the HAProxy is running
	Hostname string `json:"hostname,omitempty"`

	// mem info
	MemInfo *InfoSystemMemInfo `json:"mem_info,omitempty"`

	// OS string
	OsString string `json:"os_string,omitempty"`

	// Current time in milliseconds since Epoch.
	Time int64 `json:"time,omitempty"`

	// System uptime
	Uptime *int64 `json:"uptime,omitempty"`
}

InfoSystem info system

swagger:model InfoSystem

func (*InfoSystem) ContextValidate ¶ 

func (m *InfoSystem) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this info system based on the context it is used

func (InfoSystem) Diff ¶ added in v5.1.0 

func (s InfoSystem) Diff(t InfoSystem, opts ...Options) map[string][]interface{}

Diff checks if two structs of type InfoSystem are equal

By default empty maps and slices are equal to nil: 

var a, b InfoSystem
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b InfoSystem
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (InfoSystem) Equal ¶ added in v5.1.0 

func (s InfoSystem) Equal(t InfoSystem, opts ...Options) bool

Equal checks if two structs of type InfoSystem are equal

By default empty maps and slices are equal to nil: 

var a, b InfoSystem
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b InfoSystem
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*InfoSystem) MarshalBinary ¶ 

func (m *InfoSystem) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InfoSystem) UnmarshalBinary ¶ 

func (m *InfoSystem) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InfoSystem) Validate ¶ 

func (m *InfoSystem) Validate(formats strfmt.Registry) error

Validate validates this info system

type InfoSystemCPUInfo ¶ 

type InfoSystemCPUInfo struct {

	// model
	Model string `json:"model,omitempty"`

	// Number of logical CPUs
	NumCpus int64 `json:"num_cpus,omitempty"`
}

InfoSystemCPUInfo info system CPU info

swagger:model InfoSystemCPUInfo

func (*InfoSystemCPUInfo) ContextValidate ¶ 

func (m *InfoSystemCPUInfo) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this info system CPU info based on context it is used

func (InfoSystemCPUInfo) Diff ¶ added in v5.1.0 

func (s InfoSystemCPUInfo) Diff(t InfoSystemCPUInfo, opts ...Options) map[string][]interface{}

Diff checks if two structs of type InfoSystemCPUInfo are equal 

var a, b InfoSystemCPUInfo
diff := a.Diff(b)

opts ...Options are ignored in this method

func (InfoSystemCPUInfo) Equal ¶ added in v5.1.0 

func (s InfoSystemCPUInfo) Equal(t InfoSystemCPUInfo, opts ...Options) bool

Equal checks if two structs of type InfoSystemCPUInfo are equal 

var a, b InfoSystemCPUInfo
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*InfoSystemCPUInfo) MarshalBinary ¶ 

func (m *InfoSystemCPUInfo) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InfoSystemCPUInfo) UnmarshalBinary ¶ 

func (m *InfoSystemCPUInfo) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InfoSystemCPUInfo) Validate ¶ 

func (m *InfoSystemCPUInfo) Validate(formats strfmt.Registry) error

Validate validates this info system CPU info

type InfoSystemMemInfo ¶ 

type InfoSystemMemInfo struct {

	// dataplaneapi memory
	DataplaneapiMemory int64 `json:"dataplaneapi_memory,omitempty"`

	// free memory
	FreeMemory int64 `json:"free_memory,omitempty"`

	// total memory
	TotalMemory int64 `json:"total_memory,omitempty"`
}

InfoSystemMemInfo info system mem info

swagger:model InfoSystemMemInfo

func (*InfoSystemMemInfo) ContextValidate ¶ 

func (m *InfoSystemMemInfo) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this info system mem info based on context it is used

func (InfoSystemMemInfo) Diff ¶ added in v5.1.0 

func (s InfoSystemMemInfo) Diff(t InfoSystemMemInfo, opts ...Options) map[string][]interface{}

Diff checks if two structs of type InfoSystemMemInfo are equal 

var a, b InfoSystemMemInfo
diff := a.Diff(b)

opts ...Options are ignored in this method

func (InfoSystemMemInfo) Equal ¶ added in v5.1.0 

func (s InfoSystemMemInfo) Equal(t InfoSystemMemInfo, opts ...Options) bool

Equal checks if two structs of type InfoSystemMemInfo are equal 

var a, b InfoSystemMemInfo
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*InfoSystemMemInfo) MarshalBinary ¶ 

func (m *InfoSystemMemInfo) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InfoSystemMemInfo) UnmarshalBinary ¶ 

func (m *InfoSystemMemInfo) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InfoSystemMemInfo) Validate ¶ 

func (m *InfoSystemMemInfo) Validate(formats strfmt.Registry) error

Validate validates this info system mem info

type LogForward ¶ 

type LogForward struct {

	// backlog
	Backlog *int64 `json:"backlog,omitempty"`

	// maxconn
	Maxconn *int64 `json:"maxconn,omitempty"`

	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name string `json:"name"`

	// timeout client
	TimeoutClient *int64 `json:"timeout_client,omitempty"`
}

LogForward Log Forward

HAProxy log forward configuration ¶

swagger:model log_forward

func (*LogForward) ContextValidate ¶ 

func (m *LogForward) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this log forward based on context it is used

func (LogForward) Diff ¶ added in v5.1.0 

func (s LogForward) Diff(t LogForward, opts ...Options) map[string][]interface{}

Diff checks if two structs of type LogForward are equal 

var a, b LogForward
diff := a.Diff(b)

opts ...Options are ignored in this method

func (LogForward) Equal ¶ added in v5.1.0 

func (s LogForward) Equal(t LogForward, opts ...Options) bool

Equal checks if two structs of type LogForward are equal 

var a, b LogForward
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*LogForward) MarshalBinary ¶ 

func (m *LogForward) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*LogForward) UnmarshalBinary ¶ 

func (m *LogForward) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*LogForward) Validate ¶ 

func (m *LogForward) Validate(formats strfmt.Registry) error

Validate validates this log forward

type LogForwards ¶ 

type LogForwards []*LogForward

LogForwards Log Forwards

HAProxy log forwards array ¶

swagger:model log_forwards

func (LogForwards) ContextValidate ¶ 

func (m LogForwards) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this log forwards based on the context it is used

func (LogForwards) Diff ¶ added in v5.1.0 

func (s LogForwards) Diff(t LogForwards, opts ...Options) map[string][]interface{}

Diff checks if two structs of type LogForwards are equal

By default empty maps and slices are equal to nil: 

var a, b LogForwards
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b LogForwards
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (LogForwards) Equal ¶ added in v5.1.0 

func (s LogForwards) Equal(t LogForwards, opts ...Options) bool

Equal checks if two structs of type LogForwards are equal

By default empty maps and slices are equal to nil: 

var a, b LogForwards
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b LogForwards
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (LogForwards) Validate ¶ 

func (m LogForwards) Validate(formats strfmt.Registry) error

Validate validates this log forwards

type LogTarget ¶ 

type LogTarget struct {
	// address
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Address string `json:"address,omitempty"`

	// facility
	// Enum: [kern user mail daemon auth syslog lpr news uucp cron auth2 ftp ntp audit alert cron2 local0 local1 local2 local3 local4 local5 local6 local7]
	// +kubebuilder:validation:Enum=kern;user;mail;daemon;auth;syslog;lpr;news;uucp;cron;auth2;ftp;ntp;audit;alert;cron2;local0;local1;local2;local3;local4;local5;local6;local7;
	Facility string `json:"facility,omitempty"`

	// format
	// Enum: [local rfc3164 rfc5424 priority short timed iso raw]
	// +kubebuilder:validation:Enum=local;rfc3164;rfc5424;priority;short;timed;iso;raw;
	Format string `json:"format,omitempty"`

	// global
	Global bool `json:"global,omitempty"`

	// index
	// Required: true
	// +kubebuilder:validation:Optional
	Index *int64 `json:"index"`

	// length
	Length int64 `json:"length,omitempty"`

	// level
	// Enum: [emerg alert crit err warning notice info debug]
	// +kubebuilder:validation:Enum=emerg;alert;crit;err;warning;notice;info;debug;
	Level string `json:"level,omitempty"`

	// minlevel
	// Enum: [emerg alert crit err warning notice info debug]
	// +kubebuilder:validation:Enum=emerg;alert;crit;err;warning;notice;info;debug;
	Minlevel string `json:"minlevel,omitempty"`

	// nolog
	Nolog bool `json:"nolog,omitempty"`

	// sample range
	SampleRange string `json:"sample_range,omitempty"`

	// sample size
	SampleSize int64 `json:"sample_size,omitempty"`
}

LogTarget Log Target

Per-instance logging of events and traffic.

swagger:model log_target

func (*LogTarget) ContextValidate ¶ 

func (m *LogTarget) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this log target based on context it is used

func (LogTarget) Diff ¶ added in v5.1.0 

func (s LogTarget) Diff(t LogTarget, opts ...Options) map[string][]interface{}

Diff checks if two structs of type LogTarget are equal

By default empty maps and slices are equal to nil: 

var a, b LogTarget
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b LogTarget
diff := a.Diff(b,Options{
	SkipIndex: true,
})

func (LogTarget) Equal ¶ added in v5.1.0 

func (s LogTarget) Equal(t LogTarget, opts ...Options) bool

Equal checks if two structs of type LogTarget are equal

By default empty maps and slices are equal to nil: 

var a, b LogTarget
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b LogTarget
equal := a.Equal(b,Options{
	SkipIndex: true,
})

func (*LogTarget) MarshalBinary ¶ 

func (m *LogTarget) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*LogTarget) UnmarshalBinary ¶ 

func (m *LogTarget) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*LogTarget) Validate ¶ 

func (m *LogTarget) Validate(formats strfmt.Registry) error

Validate validates this log target

type LogTargets ¶ 

type LogTargets []*LogTarget

LogTargets Log Target Array

HAProxy log target array (corresponds to log directives)

swagger:model log_targets

func (LogTargets) ContextValidate ¶ 

func (m LogTargets) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this log targets based on the context it is used

func (LogTargets) Diff ¶ added in v5.1.0 

func (s LogTargets) Diff(t LogTargets, opts ...Options) map[string][]interface{}

Diff checks if two structs of type LogTargets are equal

By default empty maps and slices are equal to nil: 

var a, b LogTargets
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b LogTargets
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (LogTargets) Equal ¶ added in v5.1.0 

func (s LogTargets) Equal(t LogTargets, opts ...Options) bool

Equal checks if two structs of type LogTargets are equal

By default empty maps and slices are equal to nil: 

var a, b LogTargets
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b LogTargets
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (LogTargets) Validate ¶ 

func (m LogTargets) Validate(formats strfmt.Registry) error

Validate validates this log targets

type LuaLoad ¶ 

type LuaLoad struct {
	// file
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	File *string `json:"file"`
}

LuaLoad lua load

swagger:model LuaLoad

func (*LuaLoad) ContextValidate ¶ 

func (m *LuaLoad) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this lua load based on context it is used

func (LuaLoad) Diff ¶ added in v5.1.0 

func (s LuaLoad) Diff(t LuaLoad, opts ...Options) map[string][]interface{}

Diff checks if two structs of type LuaLoad are equal 

var a, b LuaLoad
diff := a.Diff(b)

opts ...Options are ignored in this method

func (LuaLoad) Equal ¶ added in v5.1.0 

func (s LuaLoad) Equal(t LuaLoad, opts ...Options) bool

Equal checks if two structs of type LuaLoad are equal 

var a, b LuaLoad
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*LuaLoad) MarshalBinary ¶ 

func (m *LuaLoad) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*LuaLoad) UnmarshalBinary ¶ 

func (m *LuaLoad) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*LuaLoad) Validate ¶ 

func (m *LuaLoad) Validate(formats strfmt.Registry) error

Validate validates this lua load

type LuaPrependPath ¶ 

type LuaPrependPath struct {
	// path
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Path *string `json:"path"`

	// type
	// Enum: [path cpath]
	// +kubebuilder:validation:Enum=path;cpath;
	Type string `json:"type,omitempty"`
}

LuaPrependPath lua prepend path

swagger:model LuaPrependPath

func (*LuaPrependPath) ContextValidate ¶ 

func (m *LuaPrependPath) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this lua prepend path based on context it is used

func (LuaPrependPath) Diff ¶ added in v5.1.0 

func (s LuaPrependPath) Diff(t LuaPrependPath, opts ...Options) map[string][]interface{}

Diff checks if two structs of type LuaPrependPath are equal 

var a, b LuaPrependPath
diff := a.Diff(b)

opts ...Options are ignored in this method

func (LuaPrependPath) Equal ¶ added in v5.1.0 

func (s LuaPrependPath) Equal(t LuaPrependPath, opts ...Options) bool

Equal checks if two structs of type LuaPrependPath are equal 

var a, b LuaPrependPath
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*LuaPrependPath) MarshalBinary ¶ 

func (m *LuaPrependPath) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*LuaPrependPath) UnmarshalBinary ¶ 

func (m *LuaPrependPath) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*LuaPrependPath) Validate ¶ 

func (m *LuaPrependPath) Validate(formats strfmt.Registry) error

Validate validates this lua prepend path

type MailerEntries ¶ 

type MailerEntries []*MailerEntry

MailerEntries Mailer Entries

HAProxy mailer entries ¶

swagger:model mailer_entries

func (MailerEntries) ContextValidate ¶ 

func (m MailerEntries) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this mailer entries based on the context it is used

func (MailerEntries) Diff ¶ added in v5.1.0 

func (s MailerEntries) Diff(t MailerEntries, opts ...Options) map[string][]interface{}

Diff checks if two structs of type MailerEntries are equal

By default empty maps and slices are equal to nil: 

var a, b MailerEntries
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b MailerEntries
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (MailerEntries) Equal ¶ added in v5.1.0 

func (s MailerEntries) Equal(t MailerEntries, opts ...Options) bool

Equal checks if two structs of type MailerEntries are equal

By default empty maps and slices are equal to nil: 

var a, b MailerEntries
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b MailerEntries
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (MailerEntries) Validate ¶ 

func (m MailerEntries) Validate(formats strfmt.Registry) error

Validate validates this mailer entries

type MailerEntry ¶ 

type MailerEntry struct {
	// address
	// Required: true
	// Pattern: ^\S+$
	// +kubebuilder:validation:Pattern=`^\S+$`
	Address string `json:"address"`

	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_]+$`
	Name string `json:"name"`

	// port
	// Required: true
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port int64 `json:"port"`
}

MailerEntry Mailer Entry

Mailer entry of a Mailers section ¶

swagger:model mailer_entry

func (*MailerEntry) ContextValidate ¶ 

func (m *MailerEntry) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this mailer entry based on context it is used

func (MailerEntry) Diff ¶ added in v5.1.0 

func (s MailerEntry) Diff(t MailerEntry, opts ...Options) map[string][]interface{}

Diff checks if two structs of type MailerEntry are equal 

var a, b MailerEntry
diff := a.Diff(b)

opts ...Options are ignored in this method

func (MailerEntry) Equal ¶ added in v5.1.0 

func (s MailerEntry) Equal(t MailerEntry, opts ...Options) bool

Equal checks if two structs of type MailerEntry are equal 

var a, b MailerEntry
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*MailerEntry) MarshalBinary ¶ 

func (m *MailerEntry) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*MailerEntry) UnmarshalBinary ¶ 

func (m *MailerEntry) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*MailerEntry) Validate ¶ 

func (m *MailerEntry) Validate(formats strfmt.Registry) error

Validate validates this mailer entry

type MailersSection ¶ 

type MailersSection struct {
	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_]+$`
	Name string `json:"name"`

	// timeout
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	Timeout *int64 `json:"timeout,omitempty"`
}

MailersSection Mailers Section

A list of SMTP servers used by HAProxy to send emails.

swagger:model mailers_section

func (*MailersSection) ContextValidate ¶ 

func (m *MailersSection) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this mailers section based on context it is used

func (MailersSection) Diff ¶ added in v5.1.0 

func (s MailersSection) Diff(t MailersSection, opts ...Options) map[string][]interface{}

Diff checks if two structs of type MailersSection are equal 

var a, b MailersSection
diff := a.Diff(b)

opts ...Options are ignored in this method

func (MailersSection) Equal ¶ added in v5.1.0 

func (s MailersSection) Equal(t MailersSection, opts ...Options) bool

Equal checks if two structs of type MailersSection are equal 

var a, b MailersSection
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*MailersSection) MarshalBinary ¶ 

func (m *MailersSection) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*MailersSection) UnmarshalBinary ¶ 

func (m *MailersSection) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*MailersSection) Validate ¶ 

func (m *MailersSection) Validate(formats strfmt.Registry) error

Validate validates this mailers section

type MailersSections ¶ 

type MailersSections []*MailersSection

MailersSections Mailers Sections

HAProxy mailers_section array

swagger:model mailers_sections

func (MailersSections) ContextValidate ¶ 

func (m MailersSections) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this mailers sections based on the context it is used

func (MailersSections) Diff ¶ added in v5.1.0 

func (s MailersSections) Diff(t MailersSections, opts ...Options) map[string][]interface{}

Diff checks if two structs of type MailersSections are equal

By default empty maps and slices are equal to nil: 

var a, b MailersSections
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b MailersSections
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (MailersSections) Equal ¶ added in v5.1.0 

func (s MailersSections) Equal(t MailersSections, opts ...Options) bool

Equal checks if two structs of type MailersSections are equal

By default empty maps and slices are equal to nil: 

var a, b MailersSections
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b MailersSections
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (MailersSections) Validate ¶ 

func (m MailersSections) Validate(formats strfmt.Registry) error

Validate validates this mailers sections

type Map ¶ 

type Map struct {

	// description
	Description string `json:"description,omitempty"`

	// file
	File string `json:"file,omitempty"`

	// id
	ID string `json:"id,omitempty"`

	// File size in bytes.
	Size *int64 `json:"size,omitempty"`

	// storage name
	StorageName string `json:"storage_name,omitempty"`
}

Map Map File

Map File ¶

swagger:model map

func (*Map) ContextValidate ¶ 

func (m *Map) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this map based on context it is used

func (Map) Diff ¶ added in v5.1.0 

func (s Map) Diff(t Map, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Map are equal 

var a, b Map
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Map) Equal ¶ added in v5.1.0 

func (s Map) Equal(t Map, opts ...Options) bool

Equal checks if two structs of type Map are equal 

var a, b Map
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Map) MarshalBinary ¶ 

func (m *Map) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Map) UnmarshalBinary ¶ 

func (m *Map) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Map) Validate ¶ 

func (m *Map) Validate(formats strfmt.Registry) error

Validate validates this map

type MapEntries ¶ 

type MapEntries []*MapEntry

MapEntries Maps Entries

Entries of one runtime map ¶

swagger:model map_entries

func (MapEntries) ContextValidate ¶ 

func (m MapEntries) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this map entries based on the context it is used

func (MapEntries) Diff ¶ added in v5.1.0 

func (s MapEntries) Diff(t MapEntries, opts ...Options) map[string][]interface{}

Diff checks if two structs of type MapEntries are equal

By default empty maps and slices are equal to nil: 

var a, b MapEntries
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b MapEntries
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (MapEntries) Equal ¶ added in v5.1.0 

func (s MapEntries) Equal(t MapEntries, opts ...Options) bool

Equal checks if two structs of type MapEntries are equal

By default empty maps and slices are equal to nil: 

var a, b MapEntries
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b MapEntries
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (MapEntries) Validate ¶ 

func (m MapEntries) Validate(formats strfmt.Registry) error

Validate validates this map entries

type MapEntry ¶ 

type MapEntry struct {

	// id
	// Read Only: true
	ID string `json:"id,omitempty"`

	// key
	Key string `json:"key,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

MapEntry One Map Entry

One Map Entry ¶

swagger:model map_entry

func (*MapEntry) ContextValidate ¶ 

func (m *MapEntry) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this map entry based on the context it is used

func (MapEntry) Diff ¶ added in v5.1.0 

func (s MapEntry) Diff(t MapEntry, opts ...Options) map[string][]interface{}

Diff checks if two structs of type MapEntry are equal 

var a, b MapEntry
diff := a.Diff(b)

opts ...Options are ignored in this method

func (MapEntry) Equal ¶ added in v5.1.0 

func (s MapEntry) Equal(t MapEntry, opts ...Options) bool

Equal checks if two structs of type MapEntry are equal 

var a, b MapEntry
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*MapEntry) MarshalBinary ¶ 

func (m *MapEntry) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*MapEntry) UnmarshalBinary ¶ 

func (m *MapEntry) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*MapEntry) Validate ¶ 

func (m *MapEntry) Validate(formats strfmt.Registry) error

Validate validates this map entry

type Maps ¶ 

type Maps []*Map

Maps Map Files Array

Array of runtime map files ¶

swagger:model maps

func (Maps) ContextValidate ¶ 

func (m Maps) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this maps based on the context it is used

func (Maps) Diff ¶ added in v5.1.0 

func (s Maps) Diff(t Maps, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Maps are equal

By default empty maps and slices are equal to nil: 

var a, b Maps
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Maps
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Maps) Equal ¶ added in v5.1.0 

func (s Maps) Equal(t Maps, opts ...Options) bool

Equal checks if two structs of type Maps are equal

By default empty maps and slices are equal to nil: 

var a, b Maps
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Maps
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Maps) Validate ¶ 

func (m Maps) Validate(formats strfmt.Registry) error

Validate validates this maps

type MonitorFail ¶ 

type MonitorFail struct {
	// cond
	// Required: true
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond *string `json:"cond"`

	// cond test
	// Required: true
	CondTest *string `json:"cond_test"`
}

MonitorFail monitor fail

swagger:model monitor_fail

func (*MonitorFail) ContextValidate ¶ 

func (m *MonitorFail) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this monitor fail based on context it is used

func (MonitorFail) Diff ¶ added in v5.1.0 

func (s MonitorFail) Diff(t MonitorFail, opts ...Options) map[string][]interface{}

Diff checks if two structs of type MonitorFail are equal 

var a, b MonitorFail
diff := a.Diff(b)

opts ...Options are ignored in this method

func (MonitorFail) Equal ¶ added in v5.1.0 

func (s MonitorFail) Equal(t MonitorFail, opts ...Options) bool

Equal checks if two structs of type MonitorFail are equal 

var a, b MonitorFail
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*MonitorFail) MarshalBinary ¶ 

func (m *MonitorFail) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*MonitorFail) UnmarshalBinary ¶ 

func (m *MonitorFail) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*MonitorFail) Validate ¶ 

func (m *MonitorFail) Validate(formats strfmt.Registry) error

Validate validates this monitor fail

type MonitorURI ¶ 

type MonitorURI string

MonitorURI monitor uri

swagger:model monitor_uri

func (MonitorURI) ContextValidate ¶ 

func (m MonitorURI) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this monitor uri based on context it is used

func (MonitorURI) Diff ¶ added in v5.1.0 

func (s MonitorURI) Diff(t MonitorURI, opts ...Options) map[string][]interface{}

Diff checks if two structs of type MonitorURI are equal 

var a, b MonitorURI
diff := a.Diff(b)

opts ...Options are ignored in this method

func (MonitorURI) Equal ¶ added in v5.1.0 

func (s MonitorURI) Equal(t MonitorURI, opts ...Options) bool

Equal checks if two structs of type MonitorURI are equal 

var a, b MonitorURI
equal := a.Equal(b)

opts ...Options are ignored in this method

func (MonitorURI) Validate ¶ 

func (m MonitorURI) Validate(formats strfmt.Registry) error

Validate validates this monitor uri

type MysqlCheckParams ¶ 

type MysqlCheckParams struct {
	// client version
	// Enum: [pre-41 post-41]
	// +kubebuilder:validation:Enum=pre-41;post-41;
	ClientVersion string `json:"client_version,omitempty"`

	// username
	Username string `json:"username,omitempty"`
}

MysqlCheckParams mysql check params

swagger:model mysql_check_params

func (*MysqlCheckParams) ContextValidate ¶ 

func (m *MysqlCheckParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this mysql check params based on context it is used

func (MysqlCheckParams) Diff ¶ added in v5.1.0 

func (s MysqlCheckParams) Diff(t MysqlCheckParams, opts ...Options) map[string][]interface{}

Diff checks if two structs of type MysqlCheckParams are equal 

var a, b MysqlCheckParams
diff := a.Diff(b)

opts ...Options are ignored in this method

func (MysqlCheckParams) Equal ¶ added in v5.1.0 

func (s MysqlCheckParams) Equal(t MysqlCheckParams, opts ...Options) bool

Equal checks if two structs of type MysqlCheckParams are equal 

var a, b MysqlCheckParams
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*MysqlCheckParams) MarshalBinary ¶ 

func (m *MysqlCheckParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*MysqlCheckParams) UnmarshalBinary ¶ 

func (m *MysqlCheckParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*MysqlCheckParams) Validate ¶ 

func (m *MysqlCheckParams) Validate(formats strfmt.Registry) error

Validate validates this mysql check params

type Nameserver ¶ 

type Nameserver struct {
	// address
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Address *string `json:"address"`

	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name string `json:"name"`

	// port
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port *int64 `json:"port,omitempty"`
}

Nameserver Nameserver

Nameserver used in Runtime DNS configuration Example: {"address":"10.0.0.1","name":"ns1","port":53}

swagger:model nameserver

func (*Nameserver) ContextValidate ¶ 

func (m *Nameserver) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this nameserver based on context it is used

func (Nameserver) Diff ¶ added in v5.1.0 

func (s Nameserver) Diff(t Nameserver, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Nameserver are equal 

var a, b Nameserver
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Nameserver) Equal ¶ added in v5.1.0 

func (s Nameserver) Equal(t Nameserver, opts ...Options) bool

Equal checks if two structs of type Nameserver are equal 

var a, b Nameserver
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Nameserver) MarshalBinary ¶ 

func (m *Nameserver) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Nameserver) UnmarshalBinary ¶ 

func (m *Nameserver) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Nameserver) Validate ¶ 

func (m *Nameserver) Validate(formats strfmt.Registry) error

Validate validates this nameserver

type Nameservers ¶ 

type Nameservers []*Nameserver

Nameservers Nameservers

Nameservers array ¶

swagger:model nameservers

func (Nameservers) ContextValidate ¶ 

func (m Nameservers) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this nameservers based on the context it is used

func (Nameservers) Diff ¶ added in v5.1.0 

func (s Nameservers) Diff(t Nameservers, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Nameservers are equal

By default empty maps and slices are equal to nil: 

var a, b Nameservers
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Nameservers
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Nameservers) Equal ¶ added in v5.1.0 

func (s Nameservers) Equal(t Nameservers, opts ...Options) bool

Equal checks if two structs of type Nameservers are equal

By default empty maps and slices are equal to nil: 

var a, b Nameservers
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Nameservers
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Nameservers) Validate ¶ 

func (m Nameservers) Validate(formats strfmt.Registry) error

Validate validates this nameservers

type NativeStat ¶ 

type NativeStat struct {

	// backend name
	BackendName string `json:"backend_name,omitempty"`

	// name
	Name string `json:"name,omitempty"`

	// stats
	Stats *NativeStatStats `json:"stats,omitempty"`

	// type
	// Enum: [backend server frontend]
	// +kubebuilder:validation:Enum=backend;server;frontend;
	Type string `json:"type,omitempty"`
}

NativeStat Stats

Current stats for one object.

swagger:model native_stat

func (*NativeStat) ContextValidate ¶ 

func (m *NativeStat) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this native stat based on the context it is used

func (NativeStat) Diff ¶ added in v5.1.0 

func (s NativeStat) Diff(t NativeStat, opts ...Options) map[string][]interface{}

Diff checks if two structs of type NativeStat are equal

By default empty maps and slices are equal to nil: 

var a, b NativeStat
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b NativeStat
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (NativeStat) Equal ¶ added in v5.1.0 

func (s NativeStat) Equal(t NativeStat, opts ...Options) bool

Equal checks if two structs of type NativeStat are equal

By default empty maps and slices are equal to nil: 

var a, b NativeStat
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b NativeStat
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*NativeStat) MarshalBinary ¶ 

func (m *NativeStat) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NativeStat) UnmarshalBinary ¶ 

func (m *NativeStat) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NativeStat) Validate ¶ 

func (m *NativeStat) Validate(formats strfmt.Registry) error

Validate validates this native stat

type NativeStatStats ¶ 

type NativeStatStats struct {

	// act
	Act *int64 `json:"act,omitempty"`

	// addr
	Addr string `json:"addr,omitempty"`

	// agent code
	AgentCode *int64 `json:"agent_code,omitempty"`

	// agent desc
	AgentDesc string `json:"agent_desc,omitempty"`

	// agent duration
	AgentDuration *int64 `json:"agent_duration,omitempty"`

	// agent fall
	AgentFall *int64 `json:"agent_fall,omitempty"`

	// agent health
	AgentHealth *int64 `json:"agent_health,omitempty"`

	// agent rise
	AgentRise *int64 `json:"agent_rise,omitempty"`

	// agent status
	// Enum: [UNK INI SOCKERR L4OK L4TOUT L4CON L7OK L7STS]
	// +kubebuilder:validation:Enum=UNK;INI;SOCKERR;L4OK;L4TOUT;L4CON;L7OK;L7STS;
	AgentStatus string `json:"agent_status,omitempty"`

	// algo
	Algo string `json:"algo,omitempty"`

	// bck
	Bck *int64 `json:"bck,omitempty"`

	// bin
	Bin *int64 `json:"bin,omitempty"`

	// bout
	Bout *int64 `json:"bout,omitempty"`

	// check code
	CheckCode *int64 `json:"check_code,omitempty"`

	// check desc
	CheckDesc string `json:"check_desc,omitempty"`

	// check duration
	CheckDuration *int64 `json:"check_duration,omitempty"`

	// check fall
	CheckFall *int64 `json:"check_fall,omitempty"`

	// check health
	CheckHealth *int64 `json:"check_health,omitempty"`

	// check rise
	CheckRise *int64 `json:"check_rise,omitempty"`

	// check status
	// Enum: [UNK INI SOCKERR L4OK L4TOUT L4CON L6OK L6TOUT L6RSP L7OK L7OKC L7TOUT L7RSP L7STS]
	// +kubebuilder:validation:Enum=UNK;INI;SOCKERR;L4OK;L4TOUT;L4CON;L6OK;L6TOUT;L6RSP;L7OK;L7OKC;L7TOUT;L7RSP;L7STS;
	CheckStatus string `json:"check_status,omitempty"`

	// chkdown
	Chkdown *int64 `json:"chkdown,omitempty"`

	// chkfail
	Chkfail *int64 `json:"chkfail,omitempty"`

	// cli abrt
	CliAbrt *int64 `json:"cli_abrt,omitempty"`

	// comp byp
	CompByp *int64 `json:"comp_byp,omitempty"`

	// comp in
	CompIn *int64 `json:"comp_in,omitempty"`

	// comp out
	CompOut *int64 `json:"comp_out,omitempty"`

	// comp rsp
	CompRsp *int64 `json:"comp_rsp,omitempty"`

	// conn rate
	ConnRate *int64 `json:"conn_rate,omitempty"`

	// conn rate max
	ConnRateMax *int64 `json:"conn_rate_max,omitempty"`

	// conn tot
	ConnTot *int64 `json:"conn_tot,omitempty"`

	// cookie
	Cookie string `json:"cookie,omitempty"`

	// ctime
	Ctime *int64 `json:"ctime,omitempty"`

	// dcon
	Dcon *int64 `json:"dcon,omitempty"`

	// downtime
	Downtime *int64 `json:"downtime,omitempty"`

	// dreq
	Dreq *int64 `json:"dreq,omitempty"`

	// dresp
	Dresp *int64 `json:"dresp,omitempty"`

	// dses
	Dses *int64 `json:"dses,omitempty"`

	// econ
	Econ *int64 `json:"econ,omitempty"`

	// ereq
	Ereq *int64 `json:"ereq,omitempty"`

	// eresp
	Eresp *int64 `json:"eresp,omitempty"`

	// hanafail
	Hanafail string `json:"hanafail,omitempty"`

	// hrsp 1xx
	Hrsp1xx *int64 `json:"hrsp_1xx,omitempty"`

	// hrsp 2xx
	Hrsp2xx *int64 `json:"hrsp_2xx,omitempty"`

	// hrsp 3xx
	Hrsp3xx *int64 `json:"hrsp_3xx,omitempty"`

	// hrsp 4xx
	Hrsp4xx *int64 `json:"hrsp_4xx,omitempty"`

	// hrsp 5xx
	Hrsp5xx *int64 `json:"hrsp_5xx,omitempty"`

	// hrsp other
	HrspOther *int64 `json:"hrsp_other,omitempty"`

	// iid
	Iid *int64 `json:"iid,omitempty"`

	// intercepted
	Intercepted *int64 `json:"intercepted,omitempty"`

	// last agt
	LastAgt *string `json:"last_agt,omitempty"`

	// last chk
	LastChk *string `json:"last_chk,omitempty"`

	// lastchg
	Lastchg *int64 `json:"lastchg,omitempty"`

	// lastsess
	Lastsess *int64 `json:"lastsess,omitempty"`

	// lbtot
	Lbtot *int64 `json:"lbtot,omitempty"`

	// mode
	// Enum: [tcp http health unknown]
	// +kubebuilder:validation:Enum=tcp;http;health;unknown;
	Mode string `json:"mode,omitempty"`

	// pid
	Pid *int64 `json:"pid,omitempty"`

	// qcur
	Qcur *int64 `json:"qcur,omitempty"`

	// qlimit
	Qlimit *int64 `json:"qlimit,omitempty"`

	// qmax
	Qmax *int64 `json:"qmax,omitempty"`

	// qtime
	Qtime *int64 `json:"qtime,omitempty"`

	// rate
	Rate *int64 `json:"rate,omitempty"`

	// rate lim
	RateLim *int64 `json:"rate_lim,omitempty"`

	// rate max
	RateMax *int64 `json:"rate_max,omitempty"`

	// req rate
	ReqRate *int64 `json:"req_rate,omitempty"`

	// req rate max
	ReqRateMax *int64 `json:"req_rate_max,omitempty"`

	// req tot
	ReqTot *int64 `json:"req_tot,omitempty"`

	// rtime
	Rtime *int64 `json:"rtime,omitempty"`

	// scur
	Scur *int64 `json:"scur,omitempty"`

	// sid
	Sid *int64 `json:"sid,omitempty"`

	// slim
	Slim *int64 `json:"slim,omitempty"`

	// smax
	Smax *int64 `json:"smax,omitempty"`

	// srv abrt
	SrvAbrt *int64 `json:"srv_abrt,omitempty"`

	// status
	// Enum: [UP DOWN NOLB MAINT no check]
	// +kubebuilder:validation:Enum=UP;DOWN;NOLB;MAINT;no;check;
	Status string `json:"status,omitempty"`

	// stot
	Stot *int64 `json:"stot,omitempty"`

	// throttle
	Throttle *int64 `json:"throttle,omitempty"`

	// tracked
	Tracked string `json:"tracked,omitempty"`

	// ttime
	Ttime *int64 `json:"ttime,omitempty"`

	// weight
	Weight *int64 `json:"weight,omitempty"`

	// wredis
	Wredis *int64 `json:"wredis,omitempty"`

	// wretr
	Wretr *int64 `json:"wretr,omitempty"`
}

NativeStatStats native stat stats Example: {"bin":4326578,"bout":889901290,"comp_byp":0,"comp_in":0,"comp_out":0,"comp_rsp":0,"conn_rate":12,"conn_rate_max":456,"conn_tot":45682,"dcon":0,"dreq":4,"dresp":1,"dses":0,"ereq":54,"hrsp_1xx":0,"hrsp_2xx":165,"hrsp_3xx":12,"hrsp_4xx":50,"hrsp_5xx":4,"hrsp_other":0,"iid":0,"intercepted":346,"last_chk":"L4OK in 0ms","mode":"http","pid":3204,"rate":64,"rate_lim":20000,"rate_max":4000,"req_rate":49,"req_rate_max":3965,"req_total":1254786,"scur":129,"slim":2000,"smax":2000,"status":"UP","stot":12902}

swagger:model native_stat_stats

func (*NativeStatStats) ContextValidate ¶ 

func (m *NativeStatStats) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this native stat stats based on context it is used

func (NativeStatStats) Diff ¶ added in v5.1.0 

func (s NativeStatStats) Diff(t NativeStatStats, opts ...Options) map[string][]interface{}

Diff checks if two structs of type NativeStatStats are equal 

var a, b NativeStatStats
diff := a.Diff(b)

opts ...Options are ignored in this method

func (NativeStatStats) Equal ¶ added in v5.1.0 

func (s NativeStatStats) Equal(t NativeStatStats, opts ...Options) bool

Equal checks if two structs of type NativeStatStats are equal 

var a, b NativeStatStats
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*NativeStatStats) MarshalBinary ¶ 

func (m *NativeStatStats) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NativeStatStats) UnmarshalBinary ¶ 

func (m *NativeStatStats) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NativeStatStats) Validate ¶ 

func (m *NativeStatStats) Validate(formats strfmt.Registry) error

Validate validates this native stat stats

type NativeStats ¶ 

type NativeStats []*NativeStatsCollection

NativeStats Stats Array

HAProxy stats array ¶

swagger:model native_stats

func (NativeStats) ContextValidate ¶ 

func (m NativeStats) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this native stats based on the context it is used

func (NativeStats) Diff ¶ added in v5.1.0 

func (s NativeStats) Diff(t NativeStats, opts ...Options) map[string][]interface{}

Diff checks if two structs of type NativeStats are equal

By default empty maps and slices are equal to nil: 

var a, b NativeStats
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b NativeStats
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (NativeStats) Equal ¶ added in v5.1.0 

func (s NativeStats) Equal(t NativeStats, opts ...Options) bool

Equal checks if two structs of type NativeStats are equal

By default empty maps and slices are equal to nil: 

var a, b NativeStats
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b NativeStats
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (NativeStats) Validate ¶ 

func (m NativeStats) Validate(formats strfmt.Registry) error

Validate validates this native stats

type NativeStatsCollection ¶ 

type NativeStatsCollection struct {

	// error
	Error string `json:"error,omitempty"`

	// runtime API
	RuntimeAPI string `json:"runtimeAPI,omitempty"`

	// stats
	Stats []*NativeStat `json:"stats,omitempty"`
}

NativeStatsCollection Stats collection

Stats from one runtime API ¶

swagger:model native_stats_collection

func (*NativeStatsCollection) ContextValidate ¶ 

func (m *NativeStatsCollection) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this native stats collection based on the context it is used

func (NativeStatsCollection) Diff ¶ added in v5.1.0 

func (s NativeStatsCollection) Diff(t NativeStatsCollection, opts ...Options) map[string][]interface{}

Diff checks if two structs of type NativeStatsCollection are equal

By default empty maps and slices are equal to nil: 

var a, b NativeStatsCollection
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b NativeStatsCollection
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (NativeStatsCollection) Equal ¶ added in v5.1.0 

func (s NativeStatsCollection) Equal(t NativeStatsCollection, opts ...Options) bool

Equal checks if two structs of type NativeStatsCollection are equal

By default empty maps and slices are equal to nil: 

var a, b NativeStatsCollection
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b NativeStatsCollection
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*NativeStatsCollection) MarshalBinary ¶ 

func (m *NativeStatsCollection) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NativeStatsCollection) UnmarshalBinary ¶ 

func (m *NativeStatsCollection) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NativeStatsCollection) Validate ¶ 

func (m *NativeStatsCollection) Validate(formats strfmt.Registry) error

Validate validates this native stats collection

type Options ¶ added in v5.1.0 

type Options struct {
	NilSameAsEmpty bool
	SkipIndex      bool
}

type Originalto ¶ 

type Originalto struct {
	// enabled
	// Required: true
	// Enum: [enabled]
	// +kubebuilder:validation:Enum=enabled;
	Enabled *string `json:"enabled"`

	// except
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Except string `json:"except,omitempty"`

	// header
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Header string `json:"header,omitempty"`
}

Originalto originalto

swagger:model originalto

func (*Originalto) ContextValidate ¶ 

func (m *Originalto) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this originalto based on context it is used

func (Originalto) Diff ¶ added in v5.1.0 

func (s Originalto) Diff(t Originalto, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Originalto are equal 

var a, b Originalto
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Originalto) Equal ¶ added in v5.1.0 

func (s Originalto) Equal(t Originalto, opts ...Options) bool

Equal checks if two structs of type Originalto are equal 

var a, b Originalto
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Originalto) MarshalBinary ¶ 

func (m *Originalto) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Originalto) UnmarshalBinary ¶ 

func (m *Originalto) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Originalto) Validate ¶ 

func (m *Originalto) Validate(formats strfmt.Registry) error

Validate validates this originalto

type PeerEntries ¶ 

type PeerEntries []*PeerEntry

PeerEntries Peer entries

HAProxy peer entries array ¶

swagger:model peer_entries

func (PeerEntries) ContextValidate ¶ 

func (m PeerEntries) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this peer entries based on the context it is used

func (PeerEntries) Diff ¶ added in v5.1.0 

func (s PeerEntries) Diff(t PeerEntries, opts ...Options) map[string][]interface{}

Diff checks if two structs of type PeerEntries are equal

By default empty maps and slices are equal to nil: 

var a, b PeerEntries
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b PeerEntries
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (PeerEntries) Equal ¶ added in v5.1.0 

func (s PeerEntries) Equal(t PeerEntries, opts ...Options) bool

Equal checks if two structs of type PeerEntries are equal

By default empty maps and slices are equal to nil: 

var a, b PeerEntries
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b PeerEntries
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (PeerEntries) Validate ¶ 

func (m PeerEntries) Validate(formats strfmt.Registry) error

Validate validates this peer entries

type PeerEntry ¶ 

type PeerEntry struct {
	// address
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Address *string `json:"address"`

	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name string `json:"name"`

	// port
	// Required: true
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port *int64 `json:"port"`

	// shard
	Shard int64 `json:"shard,omitempty"`
}

PeerEntry Peer Entry

Peer Entry from peers table ¶

swagger:model peer_entry

func (*PeerEntry) ContextValidate ¶ 

func (m *PeerEntry) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this peer entry based on context it is used

func (PeerEntry) Diff ¶ added in v5.1.0 

func (s PeerEntry) Diff(t PeerEntry, opts ...Options) map[string][]interface{}

Diff checks if two structs of type PeerEntry are equal 

var a, b PeerEntry
diff := a.Diff(b)

opts ...Options are ignored in this method

func (PeerEntry) Equal ¶ added in v5.1.0 

func (s PeerEntry) Equal(t PeerEntry, opts ...Options) bool

Equal checks if two structs of type PeerEntry are equal 

var a, b PeerEntry
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*PeerEntry) MarshalBinary ¶ 

func (m *PeerEntry) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PeerEntry) UnmarshalBinary ¶ 

func (m *PeerEntry) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PeerEntry) Validate ¶ 

func (m *PeerEntry) Validate(formats strfmt.Registry) error

Validate validates this peer entry

type PeerSection ¶ 

type PeerSection struct {

	// default bind
	DefaultBind *DefaultBind `json:"default_bind,omitempty"`

	// default server
	DefaultServer *DefaultServer `json:"default_server,omitempty"`

	// disabled
	Disabled bool `json:"disabled,omitempty"`

	// enabled
	Enabled bool `json:"enabled,omitempty"`

	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name string `json:"name"`

	// In some configurations, one would like to distribute the stick-table contents
	// to some peers in place of sending all the stick-table contents to each peer
	// declared in the "peers" section. In such cases, "shards" specifies the
	// number of peer involved in this stick-table contents distribution.
	Shards int64 `json:"shards,omitempty"`
}

PeerSection Peer Section

HAProxy peer_section configuration

swagger:model peer_section

func (*PeerSection) ContextValidate ¶ 

func (m *PeerSection) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this peer section based on the context it is used

func (PeerSection) Diff ¶ added in v5.1.0 

func (s PeerSection) Diff(t PeerSection, opts ...Options) map[string][]interface{}

Diff checks if two structs of type PeerSection are equal

By default empty maps and slices are equal to nil: 

var a, b PeerSection
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b PeerSection
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (PeerSection) Equal ¶ added in v5.1.0 

func (s PeerSection) Equal(t PeerSection, opts ...Options) bool

Equal checks if two structs of type PeerSection are equal

By default empty maps and slices are equal to nil: 

var a, b PeerSection
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b PeerSection
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*PeerSection) MarshalBinary ¶ 

func (m *PeerSection) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PeerSection) UnmarshalBinary ¶ 

func (m *PeerSection) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PeerSection) Validate ¶ 

func (m *PeerSection) Validate(formats strfmt.Registry) error

Validate validates this peer section

type PeerSections ¶ 

type PeerSections []*PeerSection

PeerSections Peer_Section

HAProxy peer_section array

swagger:model peer_sections

func (PeerSections) ContextValidate ¶ 

func (m PeerSections) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this peer sections based on the context it is used

func (PeerSections) Diff ¶ added in v5.1.0 

func (s PeerSections) Diff(t PeerSections, opts ...Options) map[string][]interface{}

Diff checks if two structs of type PeerSections are equal

By default empty maps and slices are equal to nil: 

var a, b PeerSections
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b PeerSections
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (PeerSections) Equal ¶ added in v5.1.0 

func (s PeerSections) Equal(t PeerSections, opts ...Options) bool

Equal checks if two structs of type PeerSections are equal

By default empty maps and slices are equal to nil: 

var a, b PeerSections
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b PeerSections
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (PeerSections) Validate ¶ 

func (m PeerSections) Validate(formats strfmt.Registry) error

Validate validates this peer sections

type PersistRule ¶ 

type PersistRule struct {
	// rdp cookie name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	RdpCookieName string `json:"rdp_cookie_name,omitempty"`

	// type
	// Required: true
	// Enum: [rdp-cookie]
	// +kubebuilder:validation:Enum=rdp-cookie;
	Type *string `json:"type"`
}

PersistRule persist rule

swagger:model persist_rule

func (*PersistRule) ContextValidate ¶ 

func (m *PersistRule) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this persist rule based on context it is used

func (PersistRule) Diff ¶ added in v5.1.0 

func (s PersistRule) Diff(t PersistRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type PersistRule are equal 

var a, b PersistRule
diff := a.Diff(b)

opts ...Options are ignored in this method

func (PersistRule) Equal ¶ added in v5.1.0 

func (s PersistRule) Equal(t PersistRule, opts ...Options) bool

Equal checks if two structs of type PersistRule are equal 

var a, b PersistRule
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*PersistRule) MarshalBinary ¶ 

func (m *PersistRule) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PersistRule) UnmarshalBinary ¶ 

func (m *PersistRule) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PersistRule) Validate ¶ 

func (m *PersistRule) Validate(formats strfmt.Registry) error

Validate validates this persist rule

type PgsqlCheckParams ¶ 

type PgsqlCheckParams struct {

	// username
	Username string `json:"username,omitempty"`
}

PgsqlCheckParams pgsql check params

swagger:model pgsql_check_params

func (*PgsqlCheckParams) ContextValidate ¶ 

func (m *PgsqlCheckParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pgsql check params based on context it is used

func (PgsqlCheckParams) Diff ¶ added in v5.1.0 

func (s PgsqlCheckParams) Diff(t PgsqlCheckParams, opts ...Options) map[string][]interface{}

Diff checks if two structs of type PgsqlCheckParams are equal 

var a, b PgsqlCheckParams
diff := a.Diff(b)

opts ...Options are ignored in this method

func (PgsqlCheckParams) Equal ¶ added in v5.1.0 

func (s PgsqlCheckParams) Equal(t PgsqlCheckParams, opts ...Options) bool

Equal checks if two structs of type PgsqlCheckParams are equal 

var a, b PgsqlCheckParams
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*PgsqlCheckParams) MarshalBinary ¶ 

func (m *PgsqlCheckParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PgsqlCheckParams) UnmarshalBinary ¶ 

func (m *PgsqlCheckParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PgsqlCheckParams) Validate ¶ 

func (m *PgsqlCheckParams) Validate(formats strfmt.Registry) error

Validate validates this pgsql check params

type PresetEnv ¶ 

type PresetEnv struct {

	// name
	// Required: true
	Name *string `json:"name"`

	// value
	// Required: true
	Value *string `json:"value"`
}

PresetEnv preset env

swagger:model PresetEnv

func (*PresetEnv) ContextValidate ¶ 

func (m *PresetEnv) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this preset env based on context it is used

func (PresetEnv) Diff ¶ added in v5.1.0 

func (s PresetEnv) Diff(t PresetEnv, opts ...Options) map[string][]interface{}

Diff checks if two structs of type PresetEnv are equal 

var a, b PresetEnv
diff := a.Diff(b)

opts ...Options are ignored in this method

func (PresetEnv) Equal ¶ added in v5.1.0 

func (s PresetEnv) Equal(t PresetEnv, opts ...Options) bool

Equal checks if two structs of type PresetEnv are equal 

var a, b PresetEnv
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*PresetEnv) MarshalBinary ¶ 

func (m *PresetEnv) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PresetEnv) UnmarshalBinary ¶ 

func (m *PresetEnv) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PresetEnv) Validate ¶ 

func (m *PresetEnv) Validate(formats strfmt.Registry) error

Validate validates this preset env

type ProcessInfo ¶ 

type ProcessInfo struct {

	// error
	Error string `json:"error,omitempty"`

	// info
	Info *ProcessInfoItem `json:"info,omitempty"`

	// runtime API
	RuntimeAPI string `json:"runtimeAPI,omitempty"`
}

ProcessInfo process info

swagger:model process_info

func (*ProcessInfo) ContextValidate ¶ 

func (m *ProcessInfo) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this process info based on the context it is used

func (ProcessInfo) Diff ¶ added in v5.1.0 

func (s ProcessInfo) Diff(t ProcessInfo, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ProcessInfo are equal

By default empty maps and slices are equal to nil: 

var a, b ProcessInfo
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ProcessInfo
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (ProcessInfo) Equal ¶ added in v5.1.0 

func (s ProcessInfo) Equal(t ProcessInfo, opts ...Options) bool

Equal checks if two structs of type ProcessInfo are equal

By default empty maps and slices are equal to nil: 

var a, b ProcessInfo
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ProcessInfo
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*ProcessInfo) MarshalBinary ¶ 

func (m *ProcessInfo) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ProcessInfo) UnmarshalBinary ¶ 

func (m *ProcessInfo) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ProcessInfo) Validate ¶ 

func (m *ProcessInfo) Validate(formats strfmt.Registry) error

Validate validates this process info

type ProcessInfoItem ¶ 

type ProcessInfoItem struct {

	// active peers
	ActivePeers *int64 `json:"active_peers,omitempty"`

	// busy polling
	BusyPolling *int64 `json:"busy_polling,omitempty"`

	// bytes out rate
	BytesOutRate *int64 `json:"bytes_out_rate,omitempty"`

	// compress bps in
	CompressBpsIn *int64 `json:"compress_bps_in,omitempty"`

	// compress bps out
	CompressBpsOut *int64 `json:"compress_bps_out,omitempty"`

	// compress bps rate lim
	CompressBpsRateLim *int64 `json:"compress_bps_rate_lim,omitempty"`

	// conn rate
	ConnRate *int64 `json:"conn_rate,omitempty"`

	// conn rate limit
	ConnRateLimit *int64 `json:"conn_rate_limit,omitempty"`

	// connected peers
	ConnectedPeers *int64 `json:"connected_peers,omitempty"`

	// cum conns
	CumConns *int64 `json:"cum_conns,omitempty"`

	// cum req
	CumReq *int64 `json:"cum_req,omitempty"`

	// cum ssl conns
	CumSslConns *int64 `json:"cum_ssl_conns,omitempty"`

	// curr conns
	CurrConns *int64 `json:"curr_conns,omitempty"`

	// curr ssl conns
	CurrSslConns *int64 `json:"curr_ssl_conns,omitempty"`

	// dropped logs
	DroppedLogs *int64 `json:"dropped_logs,omitempty"`

	// failed resolutions
	FailedResolutions *int64 `json:"failed_resolutions,omitempty"`

	// hard max conn
	HardMaxConn *int64 `json:"hard_max_conn,omitempty"`

	// idle pct
	IdlePct *int64 `json:"idle_pct,omitempty"`

	// jobs
	Jobs *int64 `json:"jobs,omitempty"`

	// listeners
	Listeners *int64 `json:"listeners,omitempty"`

	// max conn
	MaxConn *int64 `json:"max_conn,omitempty"`

	// max conn rate
	MaxConnRate *int64 `json:"max_conn_rate,omitempty"`

	// max pipes
	MaxPipes *int64 `json:"max_pipes,omitempty"`

	// max sess rate
	MaxSessRate *int64 `json:"max_sess_rate,omitempty"`

	// max sock
	MaxSock *int64 `json:"max_sock,omitempty"`

	// max ssl conns
	MaxSslConns *int64 `json:"max_ssl_conns,omitempty"`

	// max ssl rate
	MaxSslRate *int64 `json:"max_ssl_rate,omitempty"`

	// max zlib mem usage
	MaxZlibMemUsage *int64 `json:"max_zlib_mem_usage,omitempty"`

	// mem max mb
	MemMaxMb *int64 `json:"mem_max_mb,omitempty"`

	// Number of threads
	Nbthread *int64 `json:"nbthread,omitempty"`

	// node
	Node string `json:"node,omitempty"`

	// Process id of the replying worker process
	Pid *int64 `json:"pid,omitempty"`

	// pipes free
	PipesFree *int64 `json:"pipes_free,omitempty"`

	// pipes used
	PipesUsed *int64 `json:"pipes_used,omitempty"`

	// pool alloc mb
	PoolAllocMb *int64 `json:"pool_alloc_mb,omitempty"`

	// pool failed
	PoolFailed *int64 `json:"pool_failed,omitempty"`

	// pool used mb
	PoolUsedMb *int64 `json:"pool_used_mb,omitempty"`

	// Process number
	ProcessNum *int64 `json:"process_num,omitempty"`

	// Number of spawned processes
	Processes *int64 `json:"processes,omitempty"`

	// HAProxy version release date
	// Format: date
	// +kubebuilder:validation:Format=date
	ReleaseDate strfmt.Date `json:"release_date,omitempty"`

	// run queue
	RunQueue *int64 `json:"run_queue,omitempty"`

	// sess rate
	SessRate *int64 `json:"sess_rate,omitempty"`

	// sess rate limit
	SessRateLimit *int64 `json:"sess_rate_limit,omitempty"`

	// ssl backend key rate
	SslBackendKeyRate *int64 `json:"ssl_backend_key_rate,omitempty"`

	// ssl backend max key rate
	SslBackendMaxKeyRate *int64 `json:"ssl_backend_max_key_rate,omitempty"`

	// ssl cache lookups
	SslCacheLookups *int64 `json:"ssl_cache_lookups,omitempty"`

	// ssl cache misses
	SslCacheMisses *int64 `json:"ssl_cache_misses,omitempty"`

	// ssl frontend key rate
	SslFrontendKeyRate *int64 `json:"ssl_frontend_key_rate,omitempty"`

	// ssl frontend max key rate
	SslFrontendMaxKeyRate *int64 `json:"ssl_frontend_max_key_rate,omitempty"`

	// ssl frontend session reuse
	SslFrontendSessionReuse *int64 `json:"ssl_frontend_session_reuse,omitempty"`

	// ssl rate
	SslRate *int64 `json:"ssl_rate,omitempty"`

	// ssl rate limit
	SslRateLimit *int64 `json:"ssl_rate_limit,omitempty"`

	// stopping
	Stopping *int64 `json:"stopping,omitempty"`

	// tasks
	Tasks *int64 `json:"tasks,omitempty"`

	// total bytes out
	TotalBytesOut *int64 `json:"total_bytes_out,omitempty"`

	// ulimit n
	Ulimitn *int64 `json:"ulimit_n,omitempty"`

	// unstoppable
	Unstoppable *int64 `json:"unstoppable,omitempty"`

	// HAProxy uptime in s
	Uptime *int64 `json:"uptime,omitempty"`

	// HAProxy version string
	Version string `json:"version,omitempty"`

	// zlib mem usage
	ZlibMemUsage *int64 `json:"zlib_mem_usage,omitempty"`
}

ProcessInfoItem process info item

swagger:model process_info_item

func (*ProcessInfoItem) ContextValidate ¶ 

func (m *ProcessInfoItem) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this process info item based on context it is used

func (ProcessInfoItem) Diff ¶ added in v5.1.0 

func (s ProcessInfoItem) Diff(t ProcessInfoItem, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ProcessInfoItem are equal 

var a, b ProcessInfoItem
diff := a.Diff(b)

opts ...Options are ignored in this method

func (ProcessInfoItem) Equal ¶ added in v5.1.0 

func (s ProcessInfoItem) Equal(t ProcessInfoItem, opts ...Options) bool

Equal checks if two structs of type ProcessInfoItem are equal 

var a, b ProcessInfoItem
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*ProcessInfoItem) MarshalBinary ¶ 

func (m *ProcessInfoItem) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ProcessInfoItem) UnmarshalBinary ¶ 

func (m *ProcessInfoItem) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ProcessInfoItem) Validate ¶ 

func (m *ProcessInfoItem) Validate(formats strfmt.Registry) error

Validate validates this process info item

type ProcessInfos ¶ 

type ProcessInfos []*ProcessInfo

ProcessInfos HAProxy Information

General HAProxy process information ¶

swagger:model process_infos

func (ProcessInfos) ContextValidate ¶ 

func (m ProcessInfos) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this process infos based on the context it is used

func (ProcessInfos) Diff ¶ added in v5.1.0 

func (s ProcessInfos) Diff(t ProcessInfos, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ProcessInfos are equal

By default empty maps and slices are equal to nil: 

var a, b ProcessInfos
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ProcessInfos
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (ProcessInfos) Equal ¶ added in v5.1.0 

func (s ProcessInfos) Equal(t ProcessInfos, opts ...Options) bool

Equal checks if two structs of type ProcessInfos are equal

By default empty maps and slices are equal to nil: 

var a, b ProcessInfos
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ProcessInfos
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (ProcessInfos) Validate ¶ 

func (m ProcessInfos) Validate(formats strfmt.Registry) error

Validate validates this process infos

type Program ¶ 

type Program struct {

	// The command to be run, with flags and options.
	// Required: true
	Command *string `json:"command"`

	// The group to run the command as, if different than the HAProxy group.
	Group string `json:"group,omitempty"`

	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name string `json:"name"`

	// HAProxy stops and recreates child programs at reload.
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	StartOnReload string `json:"start-on-reload,omitempty"`

	// The user to run the command as, if different than the HAProxy user.
	User string `json:"user,omitempty"`
}

Program Program

HAProxy program configuration Example: {"command":"spoa-mirror --runtime 0 --mirror-url http://test.local","group":"mygroupname","name":"mirror","start-on-reload":"enabled","user":"myusername"}

swagger:model program

func (*Program) ContextValidate ¶ 

func (m *Program) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this program based on context it is used

func (Program) Diff ¶ added in v5.1.0 

func (s Program) Diff(t Program, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Program are equal 

var a, b Program
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Program) Equal ¶ added in v5.1.0 

func (s Program) Equal(t Program, opts ...Options) bool

Equal checks if two structs of type Program are equal 

var a, b Program
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Program) MarshalBinary ¶ 

func (m *Program) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Program) UnmarshalBinary ¶ 

func (m *Program) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Program) Validate ¶ 

func (m *Program) Validate(formats strfmt.Registry) error

Validate validates this program

type Programs ¶ 

type Programs []*Program

Programs programs

swagger:model programs

func (Programs) ContextValidate ¶ 

func (m Programs) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this programs based on the context it is used

func (Programs) Diff ¶ added in v5.1.0 

func (s Programs) Diff(t Programs, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Programs are equal

By default empty maps and slices are equal to nil: 

var a, b Programs
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Programs
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Programs) Equal ¶ added in v5.1.0 

func (s Programs) Equal(t Programs, opts ...Options) bool

Equal checks if two structs of type Programs are equal

By default empty maps and slices are equal to nil: 

var a, b Programs
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Programs
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Programs) Validate ¶ 

func (m Programs) Validate(formats strfmt.Registry) error

Validate validates this programs

type Redispatch ¶ 

type Redispatch struct {
	// enabled
	// Required: true
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Enabled *string `json:"enabled"`

	// interval
	Interval int64 `json:"interval,omitempty"`
}

Redispatch redispatch

swagger:model redispatch

func (*Redispatch) ContextValidate ¶ 

func (m *Redispatch) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this redispatch based on context it is used

func (Redispatch) Diff ¶ added in v5.1.0 

func (s Redispatch) Diff(t Redispatch, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Redispatch are equal 

var a, b Redispatch
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Redispatch) Equal ¶ added in v5.1.0 

func (s Redispatch) Equal(t Redispatch, opts ...Options) bool

Equal checks if two structs of type Redispatch are equal 

var a, b Redispatch
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Redispatch) MarshalBinary ¶ 

func (m *Redispatch) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Redispatch) UnmarshalBinary ¶ 

func (m *Redispatch) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Redispatch) Validate ¶ 

func (m *Redispatch) Validate(formats strfmt.Registry) error

Validate validates this redispatch

type Reload ¶ 

type Reload struct {
	// id
	// Pattern: ^\d{4}-\d{2}-\d{2}-\d+$
	// +kubebuilder:validation:Pattern=`^\d{4}-\d{2}-\d{2}-\d+$`
	ID string `json:"id,omitempty"`

	// reload timestamp
	ReloadTimestamp int64 `json:"reload_timestamp,omitempty"`

	// response
	Response string `json:"response,omitempty"`

	// status
	// Enum: [failed in_progress succeeded]
	// +kubebuilder:validation:Enum=failed;in_progress;succeeded;
	Status string `json:"status,omitempty"`
}

Reload HAProxy reload

HAProxy reload Example: {"id":"2019-01-03-44","status":"in_progress"}

swagger:model reload

func (*Reload) ContextValidate ¶ 

func (m *Reload) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this reload based on context it is used

func (Reload) Diff ¶ added in v5.1.0 

func (s Reload) Diff(t Reload, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Reload are equal 

var a, b Reload
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Reload) Equal ¶ added in v5.1.0 

func (s Reload) Equal(t Reload, opts ...Options) bool

Equal checks if two structs of type Reload are equal 

var a, b Reload
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Reload) MarshalBinary ¶ 

func (m *Reload) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Reload) UnmarshalBinary ¶ 

func (m *Reload) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Reload) Validate ¶ 

func (m *Reload) Validate(formats strfmt.Registry) error

Validate validates this reload

type Reloads ¶ 

type Reloads []*Reload

Reloads HAProxy Reloads Array

HAProxy reloads array ¶

swagger:model reloads

func (Reloads) ContextValidate ¶ 

func (m Reloads) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this reloads based on the context it is used

func (Reloads) Diff ¶ added in v5.1.0 

func (s Reloads) Diff(t Reloads, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Reloads are equal

By default empty maps and slices are equal to nil: 

var a, b Reloads
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Reloads
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Reloads) Equal ¶ added in v5.1.0 

func (s Reloads) Equal(t Reloads, opts ...Options) bool

Equal checks if two structs of type Reloads are equal

By default empty maps and slices are equal to nil: 

var a, b Reloads
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Reloads
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Reloads) Validate ¶ 

func (m Reloads) Validate(formats strfmt.Registry) error

Validate validates this reloads

type Resolver ¶ 

type Resolver struct {
	// accepted payload size
	// Maximum: 8192
	// Minimum: 512
	// +kubebuilder:validation:Maximum=8192
	// +kubebuilder:validation:Minimum=512
	AcceptedPayloadSize int64 `json:"accepted_payload_size,omitempty"`

	// hold nx
	HoldNx *int64 `json:"hold_nx,omitempty"`

	// hold obsolete
	HoldObsolete *int64 `json:"hold_obsolete,omitempty"`

	// hold other
	HoldOther *int64 `json:"hold_other,omitempty"`

	// hold refused
	HoldRefused *int64 `json:"hold_refused,omitempty"`

	// hold timeout
	HoldTimeout *int64 `json:"hold_timeout,omitempty"`

	// hold valid
	HoldValid *int64 `json:"hold_valid,omitempty"`

	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name string `json:"name"`

	// parse resolv conf
	ParseResolvConf bool `json:"parse-resolv-conf,omitempty"`

	// resolve retries
	// Minimum: 1
	// +kubebuilder:validation:Minimum=1
	ResolveRetries int64 `json:"resolve_retries,omitempty"`

	// timeout resolve
	TimeoutResolve int64 `json:"timeout_resolve,omitempty"`

	// timeout retry
	TimeoutRetry int64 `json:"timeout_retry,omitempty"`
}

Resolver Resolver

Runtime DNS configuration ¶

swagger:model resolver

func (*Resolver) ContextValidate ¶ 

func (m *Resolver) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this resolver based on context it is used

func (Resolver) Diff ¶ added in v5.1.0 

func (s Resolver) Diff(t Resolver, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Resolver are equal 

var a, b Resolver
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Resolver) Equal ¶ added in v5.1.0 

func (s Resolver) Equal(t Resolver, opts ...Options) bool

Equal checks if two structs of type Resolver are equal 

var a, b Resolver
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Resolver) MarshalBinary ¶ 

func (m *Resolver) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Resolver) UnmarshalBinary ¶ 

func (m *Resolver) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Resolver) Validate ¶ 

func (m *Resolver) Validate(formats strfmt.Registry) error

Validate validates this resolver

type Resolvers ¶ 

type Resolvers []*Resolver

Resolvers Resolvers

HAProxy resolvers array ¶

swagger:model resolvers

func (Resolvers) ContextValidate ¶ 

func (m Resolvers) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this resolvers based on the context it is used

func (Resolvers) Diff ¶ added in v5.1.0 

func (s Resolvers) Diff(t Resolvers, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Resolvers are equal

By default empty maps and slices are equal to nil: 

var a, b Resolvers
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Resolvers
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Resolvers) Equal ¶ added in v5.1.0 

func (s Resolvers) Equal(t Resolvers, opts ...Options) bool

Equal checks if two structs of type Resolvers are equal

By default empty maps and slices are equal to nil: 

var a, b Resolvers
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Resolvers
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Resolvers) Validate ¶ 

func (m Resolvers) Validate(formats strfmt.Registry) error

Validate validates this resolvers

type ReturnHeader ¶ 

type ReturnHeader struct {

	// fmt
	// Required: true
	Fmt *string `json:"fmt"`

	// name
	// Required: true
	Name *string `json:"name"`
}

ReturnHeader return header

swagger:model ReturnHeader

func (*ReturnHeader) ContextValidate ¶ 

func (m *ReturnHeader) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this return header based on context it is used

func (ReturnHeader) Diff ¶ added in v5.1.0 

func (s ReturnHeader) Diff(t ReturnHeader, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ReturnHeader are equal 

var a, b ReturnHeader
diff := a.Diff(b)

opts ...Options are ignored in this method

func (ReturnHeader) Equal ¶ added in v5.1.0 

func (s ReturnHeader) Equal(t ReturnHeader, opts ...Options) bool

Equal checks if two structs of type ReturnHeader are equal 

var a, b ReturnHeader
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*ReturnHeader) MarshalBinary ¶ 

func (m *ReturnHeader) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ReturnHeader) UnmarshalBinary ¶ 

func (m *ReturnHeader) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ReturnHeader) Validate ¶ 

func (m *ReturnHeader) Validate(formats strfmt.Registry) error

Validate validates this return header

type Ring ¶ 

type Ring struct {

	// description
	Description string `json:"description,omitempty"`

	// format
	// Enum: [iso local raw rfc3164 rfc5424 short priority timed]
	// +kubebuilder:validation:Enum=iso;local;raw;rfc3164;rfc5424;short;priority;timed;
	Format string `json:"format,omitempty"`

	// maxlen
	Maxlen *int64 `json:"maxlen,omitempty"`

	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name string `json:"name"`

	// size
	Size *int64 `json:"size,omitempty"`

	// timeout connect
	TimeoutConnect *int64 `json:"timeout_connect,omitempty"`

	// timeout server
	TimeoutServer *int64 `json:"timeout_server,omitempty"`
}

Ring Ring

HAProxy ring configuration ¶

swagger:model ring

func (*Ring) ContextValidate ¶ 

func (m *Ring) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this ring based on context it is used

func (Ring) Diff ¶ added in v5.1.0 

func (s Ring) Diff(t Ring, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Ring are equal 

var a, b Ring
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Ring) Equal ¶ added in v5.1.0 

func (s Ring) Equal(t Ring, opts ...Options) bool

Equal checks if two structs of type Ring are equal 

var a, b Ring
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Ring) MarshalBinary ¶ 

func (m *Ring) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Ring) UnmarshalBinary ¶ 

func (m *Ring) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Ring) Validate ¶ 

func (m *Ring) Validate(formats strfmt.Registry) error

Validate validates this ring

type Rings ¶ 

type Rings []*Ring

Rings Rings

HAProxy rings array ¶

swagger:model rings

func (Rings) ContextValidate ¶ 

func (m Rings) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this rings based on the context it is used

func (Rings) Diff ¶ added in v5.1.0 

func (s Rings) Diff(t Rings, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Rings are equal

By default empty maps and slices are equal to nil: 

var a, b Rings
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Rings
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Rings) Equal ¶ added in v5.1.0 

func (s Rings) Equal(t Rings, opts ...Options) bool

Equal checks if two structs of type Rings are equal

By default empty maps and slices are equal to nil: 

var a, b Rings
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Rings
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Rings) Validate ¶ 

func (m Rings) Validate(formats strfmt.Registry) error

Validate validates this rings

type RuntimeAPI ¶ 

type RuntimeAPI struct {
	BindParams `json:",inline"`

	// address
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Address *string `json:"address"`
}

RuntimeAPI runtime API

swagger:model RuntimeAPI

func (*RuntimeAPI) ContextValidate ¶ 

func (m *RuntimeAPI) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this runtime API based on the context it is used

func (RuntimeAPI) Diff ¶ added in v5.1.0 

func (s RuntimeAPI) Diff(t RuntimeAPI, opts ...Options) map[string][]interface{}

Diff checks if two structs of type RuntimeAPI are equal

By default empty maps and slices are equal to nil: 

var a, b RuntimeAPI
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b RuntimeAPI
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (RuntimeAPI) Equal ¶ added in v5.1.0 

func (s RuntimeAPI) Equal(t RuntimeAPI, opts ...Options) bool

Equal checks if two structs of type RuntimeAPI are equal

By default empty maps and slices are equal to nil: 

var a, b RuntimeAPI
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b RuntimeAPI
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*RuntimeAPI) MarshalBinary ¶ 

func (m *RuntimeAPI) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (RuntimeAPI) MarshalJSON ¶ 

func (m RuntimeAPI) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*RuntimeAPI) UnmarshalBinary ¶ 

func (m *RuntimeAPI) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RuntimeAPI) UnmarshalJSON ¶ 

func (m *RuntimeAPI) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*RuntimeAPI) Validate ¶ 

func (m *RuntimeAPI) Validate(formats strfmt.Registry) error

Validate validates this runtime API

type RuntimeAddServer ¶ 

type RuntimeAddServer struct {
	// address
	// Read Only: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Address string `json:"address,omitempty"`

	// agent addr
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	AgentAddr string `json:"agent-addr,omitempty"`

	// agent check
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	AgentCheck string `json:"agent-check,omitempty"`

	// agent inter
	AgentInter *int64 `json:"agent-inter,omitempty"`

	// agent port
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	AgentPort *int64 `json:"agent-port,omitempty"`

	// agent send
	AgentSend string `json:"agent-send,omitempty"`

	// allow 0rtt
	Allow0rtt bool `json:"allow_0rtt,omitempty"`

	// alpn
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Alpn string `json:"alpn,omitempty"`

	// backup
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Backup string `json:"backup,omitempty"`

	// check
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Check string `json:"check,omitempty"`

	// check send proxy
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	CheckSendProxy string `json:"check-send-proxy,omitempty"`

	// check sni
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	CheckSni string `json:"check-sni,omitempty"`

	// check ssl
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	CheckSsl string `json:"check-ssl,omitempty"`

	// check alpn
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	CheckAlpn string `json:"check_alpn,omitempty"`

	// check proto
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	CheckProto string `json:"check_proto,omitempty"`

	// check via socks4
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	CheckViaSocks4 string `json:"check_via_socks4,omitempty"`

	// ciphers
	Ciphers string `json:"ciphers,omitempty"`

	// ciphersuites
	Ciphersuites string `json:"ciphersuites,omitempty"`

	// crl file
	CrlFile string `json:"crl_file,omitempty"`

	// downinter
	Downinter *int64 `json:"downinter,omitempty"`

	// error limit
	ErrorLimit *int64 `json:"error_limit,omitempty"`

	// fall
	Fall *int64 `json:"fall,omitempty"`

	// fastinter
	Fastinter *int64 `json:"fastinter,omitempty"`

	// force sslv3
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	ForceSslv3 string `json:"force_sslv3,omitempty"`

	// force tlsv10
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	ForceTlsv10 string `json:"force_tlsv10,omitempty"`

	// force tlsv11
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	ForceTlsv11 string `json:"force_tlsv11,omitempty"`

	// force tlsv12
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	ForceTlsv12 string `json:"force_tlsv12,omitempty"`

	// force tlsv13
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	ForceTlsv13 string `json:"force_tlsv13,omitempty"`

	// health check address
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	HealthCheckAddress string `json:"health_check_address,omitempty"`

	// health check port
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	HealthCheckPort *int64 `json:"health_check_port,omitempty"`

	// id
	// Read Only: true
	ID string `json:"id,omitempty"`

	// inter
	Inter *int64 `json:"inter,omitempty"`

	// maintenance
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Maintenance string `json:"maintenance,omitempty"`

	// maxconn
	Maxconn *int64 `json:"maxconn,omitempty"`

	// maxqueue
	Maxqueue *int64 `json:"maxqueue,omitempty"`

	// minconn
	Minconn *int64 `json:"minconn,omitempty"`

	// name
	// Read Only: true
	Name string `json:"name,omitempty"`

	// no sslv3
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	NoSslv3 string `json:"no_sslv3,omitempty"`

	// no tlsv10
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	NoTlsv10 string `json:"no_tlsv10,omitempty"`

	// no tlsv11
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	NoTlsv11 string `json:"no_tlsv11,omitempty"`

	// no tlsv12
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	NoTlsv12 string `json:"no_tlsv12,omitempty"`

	// no tlsv13
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	NoTlsv13 string `json:"no_tlsv13,omitempty"`

	// npn
	Npn string `json:"npn,omitempty"`

	// observe
	// Enum: [layer4 layer7]
	// +kubebuilder:validation:Enum=layer4;layer7;
	Observe string `json:"observe,omitempty"`

	// on error
	// Enum: [fastinter fail-check sudden-death mark-down]
	// +kubebuilder:validation:Enum=fastinter;fail-check;sudden-death;mark-down;
	OnError string `json:"on-error,omitempty"`

	// on marked down
	// Enum: [shutdown-sessions]
	// +kubebuilder:validation:Enum=shutdown-sessions;
	OnMarkedDown string `json:"on-marked-down,omitempty"`

	// on marked up
	// Enum: [shutdown-backup-sessions]
	// +kubebuilder:validation:Enum=shutdown-backup-sessions;
	OnMarkedUp string `json:"on-marked-up,omitempty"`

	// pool low conn
	PoolLowConn *int64 `json:"pool_low_conn,omitempty"`

	// pool max conn
	PoolMaxConn *int64 `json:"pool_max_conn,omitempty"`

	// pool purge delay
	PoolPurgeDelay *int64 `json:"pool_purge_delay,omitempty"`

	// port
	// Read Only: true
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port *int64 `json:"port,omitempty"`

	// proto
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Proto string `json:"proto,omitempty"`

	// proxy v2 options
	ProxyV2Options []string `json:"proxy-v2-options,omitempty"`

	// rise
	Rise *int64 `json:"rise,omitempty"`

	// send proxy
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SendProxy string `json:"send-proxy,omitempty"`

	// send proxy v2
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SendProxyV2 string `json:"send-proxy-v2,omitempty"`

	// send proxy v2 ssl
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SendProxyV2Ssl string `json:"send_proxy_v2_ssl,omitempty"`

	// send proxy v2 ssl cn
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SendProxyV2SslCn string `json:"send_proxy_v2_ssl_cn,omitempty"`

	// slowstart
	Slowstart *int64 `json:"slowstart,omitempty"`

	// sni
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Sni string `json:"sni,omitempty"`

	// source
	Source string `json:"source,omitempty"`

	// ssl
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Ssl string `json:"ssl,omitempty"`

	// ssl cafile
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	SslCafile string `json:"ssl_cafile,omitempty"`

	// ssl certificate
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	SslCertificate string `json:"ssl_certificate,omitempty"`

	// ssl max ver
	// Enum: [SSLv3 TLSv1.0 TLSv1.1 TLSv1.2 TLSv1.3]
	// +kubebuilder:validation:Enum=SSLv3;TLSv1.0;TLSv1.1;TLSv1.2;TLSv1.3;
	SslMaxVer string `json:"ssl_max_ver,omitempty"`

	// ssl min ver
	// Enum: [SSLv3 TLSv1.0 TLSv1.1 TLSv1.2 TLSv1.3]
	// +kubebuilder:validation:Enum=SSLv3;TLSv1.0;TLSv1.1;TLSv1.2;TLSv1.3;
	SslMinVer string `json:"ssl_min_ver,omitempty"`

	// ssl reuse
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SslReuse string `json:"ssl_reuse,omitempty"`

	// tfo
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Tfo string `json:"tfo,omitempty"`

	// tls tickets
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	TLSTickets string `json:"tls_tickets,omitempty"`

	// track
	Track string `json:"track,omitempty"`

	// verify
	// Enum: [none required]
	// +kubebuilder:validation:Enum=none;required;
	Verify string `json:"verify,omitempty"`

	// verifyhost
	Verifyhost string `json:"verifyhost,omitempty"`

	// weight
	Weight *int64 `json:"weight,omitempty"`

	// ws
	// Enum: [auto h1 h2]
	// +kubebuilder:validation:Enum=auto;h1;h2;
	Ws string `json:"ws,omitempty"`
}

RuntimeAddServer Runtime Add Server

Settable properties when adding a new server using HAProxy's runtime.

swagger:model runtime_add_server

func (*RuntimeAddServer) ContextValidate ¶ 

func (m *RuntimeAddServer) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this runtime add server based on the context it is used

func (RuntimeAddServer) Diff ¶ added in v5.1.0 

func (s RuntimeAddServer) Diff(t RuntimeAddServer, opts ...Options) map[string][]interface{}

Diff checks if two structs of type RuntimeAddServer are equal

By default empty maps and slices are equal to nil: 

var a, b RuntimeAddServer
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b RuntimeAddServer
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (RuntimeAddServer) Equal ¶ added in v5.1.0 

func (s RuntimeAddServer) Equal(t RuntimeAddServer, opts ...Options) bool

Equal checks if two structs of type RuntimeAddServer are equal

By default empty maps and slices are equal to nil: 

var a, b RuntimeAddServer
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b RuntimeAddServer
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*RuntimeAddServer) MarshalBinary ¶ 

func (m *RuntimeAddServer) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RuntimeAddServer) UnmarshalBinary ¶ 

func (m *RuntimeAddServer) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RuntimeAddServer) Validate ¶ 

func (m *RuntimeAddServer) Validate(formats strfmt.Registry) error

Validate validates this runtime add server

type RuntimeServer ¶ 

type RuntimeServer struct {
	// address
	// Read Only: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Address string `json:"address,omitempty"`

	// admin state
	// Enum: [ready maint drain]
	// +kubebuilder:validation:Enum=ready;maint;drain;
	AdminState string `json:"admin_state,omitempty"`

	// id
	// Read Only: true
	ID string `json:"id,omitempty"`

	// name
	// Read Only: true
	Name string `json:"name,omitempty"`

	// operational state
	// Enum: [up down stopping]
	// +kubebuilder:validation:Enum=up;down;stopping;
	OperationalState string `json:"operational_state,omitempty"`

	// port
	// Read Only: true
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port *int64 `json:"port,omitempty"`
}

RuntimeServer Runtime Server

Runtime transient server properties Example: {"address":"127.0.0.5","admin_state":"ready","operational_state":"up","port":80,"server_id":1,"server_name":"web_server"}

swagger:model runtime_server

func (*RuntimeServer) ContextValidate ¶ 

func (m *RuntimeServer) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this runtime server based on the context it is used

func (RuntimeServer) Diff ¶ added in v5.1.0 

func (s RuntimeServer) Diff(t RuntimeServer, opts ...Options) map[string][]interface{}

Diff checks if two structs of type RuntimeServer are equal 

var a, b RuntimeServer
diff := a.Diff(b)

opts ...Options are ignored in this method

func (RuntimeServer) Equal ¶ added in v5.1.0 

func (s RuntimeServer) Equal(t RuntimeServer, opts ...Options) bool

Equal checks if two structs of type RuntimeServer are equal 

var a, b RuntimeServer
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*RuntimeServer) MarshalBinary ¶ 

func (m *RuntimeServer) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RuntimeServer) UnmarshalBinary ¶ 

func (m *RuntimeServer) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RuntimeServer) Validate ¶ 

func (m *RuntimeServer) Validate(formats strfmt.Registry) error

Validate validates this runtime server

type RuntimeServers ¶ 

type RuntimeServers []*RuntimeServer

RuntimeServers HAProxy Runtime Servers Array

HAProxy runtime servers array ¶

swagger:model runtime_servers

func (RuntimeServers) ContextValidate ¶ 

func (m RuntimeServers) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this runtime servers based on the context it is used

func (RuntimeServers) Diff ¶ added in v5.1.0 

func (s RuntimeServers) Diff(t RuntimeServers, opts ...Options) map[string][]interface{}

Diff checks if two structs of type RuntimeServers are equal

By default empty maps and slices are equal to nil: 

var a, b RuntimeServers
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b RuntimeServers
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (RuntimeServers) Equal ¶ added in v5.1.0 

func (s RuntimeServers) Equal(t RuntimeServers, opts ...Options) bool

Equal checks if two structs of type RuntimeServers are equal

By default empty maps and slices are equal to nil: 

var a, b RuntimeServers
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b RuntimeServers
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (RuntimeServers) Validate ¶ 

func (m RuntimeServers) Validate(formats strfmt.Registry) error

Validate validates this runtime servers

type Server ¶ 

type Server struct {
	ServerParams `json:",inline"`

	// address
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Address string `json:"address"`

	// id
	ID *int64 `json:"id,omitempty"`

	// name
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Name string `json:"name"`

	// port
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port *int64 `json:"port,omitempty"`
}

Server Server

HAProxy backend server configuration Example: {"address":"10.1.1.1","name":"www","port":8080}

swagger:model server

func (*Server) ContextValidate ¶ 

func (m *Server) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this server based on the context it is used

func (Server) Diff ¶ added in v5.1.0 

func (s Server) Diff(t Server, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Server are equal

By default empty maps and slices are equal to nil: 

var a, b Server
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Server
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Server) Equal ¶ added in v5.1.0 

func (s Server) Equal(t Server, opts ...Options) bool

Equal checks if two structs of type Server are equal

By default empty maps and slices are equal to nil: 

var a, b Server
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Server
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Server) MarshalBinary ¶ 

func (m *Server) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Server) MarshalJSON ¶ 

func (m Server) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*Server) UnmarshalBinary ¶ 

func (m *Server) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Server) UnmarshalJSON ¶ 

func (m *Server) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*Server) Validate ¶ 

func (m *Server) Validate(formats strfmt.Registry) error

Validate validates this server

type ServerParams ¶ 

type ServerParams struct {
	// agent addr
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	AgentAddr string `json:"agent-addr,omitempty"`

	// agent check
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	AgentCheck string `json:"agent-check,omitempty"`

	// agent inter
	AgentInter *int64 `json:"agent-inter,omitempty"`

	// agent port
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	AgentPort *int64 `json:"agent-port,omitempty"`

	// agent send
	AgentSend string `json:"agent-send,omitempty"`

	// allow 0rtt
	Allow0rtt bool `json:"allow_0rtt,omitempty"`

	// alpn
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Alpn string `json:"alpn,omitempty"`

	// backup
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Backup string `json:"backup,omitempty"`

	// check
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Check string `json:"check,omitempty"`

	// check send proxy
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	CheckSendProxy string `json:"check-send-proxy,omitempty"`

	// check sni
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	CheckSni string `json:"check-sni,omitempty"`

	// check ssl
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	CheckSsl string `json:"check-ssl,omitempty"`

	// check alpn
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	CheckAlpn string `json:"check_alpn,omitempty"`

	// check proto
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	CheckProto string `json:"check_proto,omitempty"`

	// check via socks4
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	CheckViaSocks4 string `json:"check_via_socks4,omitempty"`

	// ciphers
	Ciphers string `json:"ciphers,omitempty"`

	// ciphersuites
	Ciphersuites string `json:"ciphersuites,omitempty"`

	// client sigalgs
	ClientSigalgs string `json:"client_sigalgs,omitempty"`

	// cookie
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Cookie string `json:"cookie,omitempty"`

	// crl file
	CrlFile string `json:"crl_file,omitempty"`

	// curves
	Curves string `json:"curves,omitempty"`

	// downinter
	Downinter *int64 `json:"downinter,omitempty"`

	// error limit
	ErrorLimit int64 `json:"error_limit,omitempty"`

	// fall
	Fall *int64 `json:"fall,omitempty"`

	// fastinter
	Fastinter *int64 `json:"fastinter,omitempty"`

	// force sslv3
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	ForceSslv3 string `json:"force_sslv3,omitempty"`

	// force tlsv10
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	ForceTlsv10 string `json:"force_tlsv10,omitempty"`

	// force tlsv11
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	ForceTlsv11 string `json:"force_tlsv11,omitempty"`

	// force tlsv12
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	ForceTlsv12 string `json:"force_tlsv12,omitempty"`

	// force tlsv13
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	ForceTlsv13 string `json:"force_tlsv13,omitempty"`

	// health check address
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	HealthCheckAddress string `json:"health_check_address,omitempty"`

	// health check port
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	HealthCheckPort *int64 `json:"health_check_port,omitempty"`

	// init addr
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	InitAddr *string `json:"init-addr,omitempty"`

	// inter
	Inter *int64 `json:"inter,omitempty"`

	// log bufsize
	LogBufsize *int64 `json:"log-bufsize,omitempty"`

	// log proto
	// Enum: [legacy octet-count]
	// +kubebuilder:validation:Enum=legacy;octet-count;
	LogProto string `json:"log_proto,omitempty"`

	// maintenance
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Maintenance string `json:"maintenance,omitempty"`

	// max reuse
	MaxReuse *int64 `json:"max_reuse,omitempty"`

	// maxconn
	Maxconn *int64 `json:"maxconn,omitempty"`

	// maxqueue
	Maxqueue *int64 `json:"maxqueue,omitempty"`

	// minconn
	Minconn *int64 `json:"minconn,omitempty"`

	// namespace
	Namespace string `json:"namespace,omitempty"`

	// no sslv3
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	NoSslv3 string `json:"no_sslv3,omitempty"`

	// no tlsv10
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	NoTlsv10 string `json:"no_tlsv10,omitempty"`

	// no tlsv11
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	NoTlsv11 string `json:"no_tlsv11,omitempty"`

	// no tlsv12
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	NoTlsv12 string `json:"no_tlsv12,omitempty"`

	// no tlsv13
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	NoTlsv13 string `json:"no_tlsv13,omitempty"`

	// no verifyhost
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	NoVerifyhost string `json:"no_verifyhost,omitempty"`

	// npn
	Npn string `json:"npn,omitempty"`

	// observe
	// Enum: [layer4 layer7]
	// +kubebuilder:validation:Enum=layer4;layer7;
	Observe string `json:"observe,omitempty"`

	// on error
	// Enum: [fastinter fail-check sudden-death mark-down]
	// +kubebuilder:validation:Enum=fastinter;fail-check;sudden-death;mark-down;
	OnError string `json:"on-error,omitempty"`

	// on marked down
	// Enum: [shutdown-sessions]
	// +kubebuilder:validation:Enum=shutdown-sessions;
	OnMarkedDown string `json:"on-marked-down,omitempty"`

	// on marked up
	// Enum: [shutdown-backup-sessions]
	// +kubebuilder:validation:Enum=shutdown-backup-sessions;
	OnMarkedUp string `json:"on-marked-up,omitempty"`

	// pool low conn
	PoolLowConn *int64 `json:"pool_low_conn,omitempty"`

	// pool max conn
	PoolMaxConn *int64 `json:"pool_max_conn,omitempty"`

	// pool purge delay
	PoolPurgeDelay *int64 `json:"pool_purge_delay,omitempty"`

	// proto
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Proto string `json:"proto,omitempty"`

	// proxy v2 options
	ProxyV2Options []string `json:"proxy-v2-options,omitempty"`

	// redir
	Redir string `json:"redir,omitempty"`

	// resolve net
	// Pattern: ^([A-Za-z0-9.:/]+)(,[A-Za-z0-9.:/]+)*$
	// +kubebuilder:validation:Pattern=`^([A-Za-z0-9.:/]+)(,[A-Za-z0-9.:/]+)*$`
	ResolveNet string `json:"resolve-net,omitempty"`

	// resolve prefer
	// Enum: [ipv4 ipv6]
	// +kubebuilder:validation:Enum=ipv4;ipv6;
	ResolvePrefer string `json:"resolve-prefer,omitempty"`

	// resolve opts
	// Pattern: ^(allow-dup-ip|ignore-weight|prevent-dup-ip)(,(allow-dup-ip|ignore-weight|prevent-dup-ip))*$
	// +kubebuilder:validation:Pattern=`^(allow-dup-ip|ignore-weight|prevent-dup-ip)(,(allow-dup-ip|ignore-weight|prevent-dup-ip))*$`
	ResolveOpts string `json:"resolve_opts,omitempty"`

	// resolvers
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Resolvers string `json:"resolvers,omitempty"`

	// rise
	Rise *int64 `json:"rise,omitempty"`

	// send proxy
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SendProxy string `json:"send-proxy,omitempty"`

	// send proxy v2
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SendProxyV2 string `json:"send-proxy-v2,omitempty"`

	// send proxy v2 ssl
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SendProxyV2Ssl string `json:"send_proxy_v2_ssl,omitempty"`

	// send proxy v2 ssl cn
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SendProxyV2SslCn string `json:"send_proxy_v2_ssl_cn,omitempty"`

	// set proxy v2 tlv fmt
	SetProxyV2TlvFmt *ServerParamsSetProxyV2TlvFmt `json:"set-proxy-v2-tlv-fmt,omitempty"`

	// shard
	Shard int64 `json:"shard,omitempty"`

	// sigalgs
	Sigalgs string `json:"sigalgs,omitempty"`

	// slowstart
	Slowstart *int64 `json:"slowstart,omitempty"`

	// sni
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Sni string `json:"sni,omitempty"`

	// socks4
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Socks4 string `json:"socks4,omitempty"`

	// source
	Source string `json:"source,omitempty"`

	// ssl
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Ssl string `json:"ssl,omitempty"`

	// ssl cafile
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	SslCafile string `json:"ssl_cafile,omitempty"`

	// ssl certificate
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	SslCertificate string `json:"ssl_certificate,omitempty"`

	// ssl max ver
	// Enum: [SSLv3 TLSv1.0 TLSv1.1 TLSv1.2 TLSv1.3]
	// +kubebuilder:validation:Enum=SSLv3;TLSv1.0;TLSv1.1;TLSv1.2;TLSv1.3;
	SslMaxVer string `json:"ssl_max_ver,omitempty"`

	// ssl min ver
	// Enum: [SSLv3 TLSv1.0 TLSv1.1 TLSv1.2 TLSv1.3]
	// +kubebuilder:validation:Enum=SSLv3;TLSv1.0;TLSv1.1;TLSv1.2;TLSv1.3;
	SslMinVer string `json:"ssl_min_ver,omitempty"`

	// ssl reuse
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SslReuse string `json:"ssl_reuse,omitempty"`

	// stick
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Stick string `json:"stick,omitempty"`

	// tcp ut
	TCPUt *int64 `json:"tcp_ut,omitempty"`

	// tfo
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Tfo string `json:"tfo,omitempty"`

	// tls tickets
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	TLSTickets string `json:"tls_tickets,omitempty"`

	// track
	Track string `json:"track,omitempty"`

	// verify
	// Enum: [none required]
	// +kubebuilder:validation:Enum=none;required;
	Verify string `json:"verify,omitempty"`

	// verifyhost
	Verifyhost string `json:"verifyhost,omitempty"`

	// weight
	Weight *int64 `json:"weight,omitempty"`

	// ws
	// Enum: [auto h1 h2]
	// +kubebuilder:validation:Enum=auto;h1;h2;
	Ws string `json:"ws,omitempty"`
}

ServerParams server params

swagger:model server_params

func (*ServerParams) ContextValidate ¶ 

func (m *ServerParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this server params based on the context it is used

func (ServerParams) Diff ¶ added in v5.1.0 

func (s ServerParams) Diff(t ServerParams, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ServerParams are equal

By default empty maps and slices are equal to nil: 

var a, b ServerParams
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ServerParams
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (ServerParams) Equal ¶ added in v5.1.0 

func (s ServerParams) Equal(t ServerParams, opts ...Options) bool

Equal checks if two structs of type ServerParams are equal

By default empty maps and slices are equal to nil: 

var a, b ServerParams
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ServerParams
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*ServerParams) MarshalBinary ¶ 

func (m *ServerParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (ServerParams) PrepareFieldsForRuntimeAddServer ¶ added in v5.1.15 

func (s ServerParams) PrepareFieldsForRuntimeAddServer() *ServerParams

func (*ServerParams) UnmarshalBinary ¶ 

func (m *ServerParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ServerParams) Validate ¶ 

func (m *ServerParams) Validate(formats strfmt.Registry) error

Validate validates this server params

type ServerParamsSetProxyV2TlvFmt ¶ added in v5.1.0 

type ServerParamsSetProxyV2TlvFmt struct {

	// id
	// Required: true
	ID *string `json:"id"`

	// value
	// Required: true
	Value *string `json:"value"`
}

ServerParamsSetProxyV2TlvFmt server params set proxy v2 tlv fmt

swagger:model ServerParamsSetProxyV2TlvFmt

func (*ServerParamsSetProxyV2TlvFmt) ContextValidate ¶ added in v5.1.0 

func (m *ServerParamsSetProxyV2TlvFmt) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this server params set proxy v2 tlv fmt based on context it is used

func (ServerParamsSetProxyV2TlvFmt) Diff ¶ added in v5.1.0 

func (s ServerParamsSetProxyV2TlvFmt) Diff(t ServerParamsSetProxyV2TlvFmt, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ServerParamsSetProxyV2TlvFmt are equal 

var a, b ServerParamsSetProxyV2TlvFmt
diff := a.Diff(b)

opts ...Options are ignored in this method

func (ServerParamsSetProxyV2TlvFmt) Equal ¶ added in v5.1.0 

func (s ServerParamsSetProxyV2TlvFmt) Equal(t ServerParamsSetProxyV2TlvFmt, opts ...Options) bool

Equal checks if two structs of type ServerParamsSetProxyV2TlvFmt are equal 

var a, b ServerParamsSetProxyV2TlvFmt
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*ServerParamsSetProxyV2TlvFmt) MarshalBinary ¶ added in v5.1.0 

func (m *ServerParamsSetProxyV2TlvFmt) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ServerParamsSetProxyV2TlvFmt) UnmarshalBinary ¶ added in v5.1.0 

func (m *ServerParamsSetProxyV2TlvFmt) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ServerParamsSetProxyV2TlvFmt) Validate ¶ added in v5.1.0 

func (m *ServerParamsSetProxyV2TlvFmt) Validate(formats strfmt.Registry) error

Validate validates this server params set proxy v2 tlv fmt

type ServerSwitchingRule ¶ 

type ServerSwitchingRule struct {
	// cond
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond string `json:"cond,omitempty"`

	// cond test
	CondTest string `json:"cond_test,omitempty"`

	// index
	// Required: true
	// +kubebuilder:validation:Optional
	Index *int64 `json:"index"`

	// target server
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	TargetServer string `json:"target_server"`
}

ServerSwitchingRule Server Switching Rule

HAProxy server switching rule configuration (corresponds to use-server directive) Example: {"cond":"if","cond_test":"{ req_ssl_sni -i www.example.com }","index":0,"target_server":"www"}

swagger:model server_switching_rule

func (*ServerSwitchingRule) ContextValidate ¶ 

func (m *ServerSwitchingRule) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this server switching rule based on context it is used

func (ServerSwitchingRule) Diff ¶ added in v5.1.0 

func (s ServerSwitchingRule) Diff(t ServerSwitchingRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ServerSwitchingRule are equal

By default empty maps and slices are equal to nil: 

var a, b ServerSwitchingRule
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ServerSwitchingRule
diff := a.Diff(b,Options{
	SkipIndex: true,
})

func (ServerSwitchingRule) Equal ¶ added in v5.1.0 

func (s ServerSwitchingRule) Equal(t ServerSwitchingRule, opts ...Options) bool

Equal checks if two structs of type ServerSwitchingRule are equal

By default empty maps and slices are equal to nil: 

var a, b ServerSwitchingRule
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ServerSwitchingRule
equal := a.Equal(b,Options{
	SkipIndex: true,
})

func (*ServerSwitchingRule) MarshalBinary ¶ 

func (m *ServerSwitchingRule) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ServerSwitchingRule) UnmarshalBinary ¶ 

func (m *ServerSwitchingRule) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ServerSwitchingRule) Validate ¶ 

func (m *ServerSwitchingRule) Validate(formats strfmt.Registry) error

Validate validates this server switching rule

type ServerSwitchingRules ¶ 

type ServerSwitchingRules []*ServerSwitchingRule

ServerSwitchingRules Server Switching Rules Array

HAProxy backend server switching rules array (corresponds to use-server directives)

swagger:model server_switching_rules

func (ServerSwitchingRules) ContextValidate ¶ 

func (m ServerSwitchingRules) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this server switching rules based on the context it is used

func (ServerSwitchingRules) Diff ¶ added in v5.1.0 

func (s ServerSwitchingRules) Diff(t ServerSwitchingRules, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ServerSwitchingRules are equal

By default empty maps and slices are equal to nil: 

var a, b ServerSwitchingRules
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ServerSwitchingRules
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (ServerSwitchingRules) Equal ¶ added in v5.1.0 

func (s ServerSwitchingRules) Equal(t ServerSwitchingRules, opts ...Options) bool

Equal checks if two structs of type ServerSwitchingRules are equal

By default empty maps and slices are equal to nil: 

var a, b ServerSwitchingRules
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ServerSwitchingRules
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (ServerSwitchingRules) Validate ¶ 

func (m ServerSwitchingRules) Validate(formats strfmt.Registry) error

Validate validates this server switching rules

type ServerTemplate ¶ 

type ServerTemplate struct {
	ServerParams `json:",inline"`

	// fqdn
	// Required: true
	Fqdn string `json:"fqdn"`

	// id
	ID *int64 `json:"id,omitempty"`

	// num or range
	// Required: true
	NumOrRange string `json:"num_or_range"`

	// port
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port *int64 `json:"port,omitempty"`

	// prefix
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Prefix string `json:"prefix"`
}

ServerTemplate Server template

Set a template to initialize servers with shared parameters. Example: {"fqdn":"google.com","num_or_range":"1-3","port":80,"prefix":"srv"}

swagger:model server_template

func (*ServerTemplate) ContextValidate ¶ 

func (m *ServerTemplate) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this server template based on the context it is used

func (ServerTemplate) Diff ¶ added in v5.1.0 

func (s ServerTemplate) Diff(t ServerTemplate, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ServerTemplate are equal

By default empty maps and slices are equal to nil: 

var a, b ServerTemplate
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ServerTemplate
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (ServerTemplate) Equal ¶ added in v5.1.0 

func (s ServerTemplate) Equal(t ServerTemplate, opts ...Options) bool

Equal checks if two structs of type ServerTemplate are equal

By default empty maps and slices are equal to nil: 

var a, b ServerTemplate
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ServerTemplate
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*ServerTemplate) MarshalBinary ¶ 

func (m *ServerTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (ServerTemplate) MarshalJSON ¶ 

func (m ServerTemplate) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*ServerTemplate) UnmarshalBinary ¶ 

func (m *ServerTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ServerTemplate) UnmarshalJSON ¶ 

func (m *ServerTemplate) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*ServerTemplate) Validate ¶ 

func (m *ServerTemplate) Validate(formats strfmt.Registry) error

Validate validates this server template

type ServerTemplates ¶ 

type ServerTemplates []*ServerTemplate

ServerTemplates Server templates

HAProxy backend server templates array ¶

swagger:model server_templates

func (ServerTemplates) ContextValidate ¶ 

func (m ServerTemplates) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this server templates based on the context it is used

func (ServerTemplates) Diff ¶ added in v5.1.0 

func (s ServerTemplates) Diff(t ServerTemplates, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ServerTemplates are equal

By default empty maps and slices are equal to nil: 

var a, b ServerTemplates
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ServerTemplates
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (ServerTemplates) Equal ¶ added in v5.1.0 

func (s ServerTemplates) Equal(t ServerTemplates, opts ...Options) bool

Equal checks if two structs of type ServerTemplates are equal

By default empty maps and slices are equal to nil: 

var a, b ServerTemplates
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b ServerTemplates
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (ServerTemplates) Validate ¶ 

func (m ServerTemplates) Validate(formats strfmt.Registry) error

Validate validates this server templates

type Servers ¶ 

type Servers []*Server

Servers Servers

HAProxy backend servers array ¶

swagger:model servers

func (Servers) ContextValidate ¶ 

func (m Servers) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this servers based on the context it is used

func (Servers) Diff ¶ added in v5.1.0 

func (s Servers) Diff(t Servers, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Servers are equal

By default empty maps and slices are equal to nil: 

var a, b Servers
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Servers
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Servers) Equal ¶ added in v5.1.0 

func (s Servers) Equal(t Servers, opts ...Options) bool

Equal checks if two structs of type Servers are equal

By default empty maps and slices are equal to nil: 

var a, b Servers
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Servers
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Servers) Validate ¶ 

func (m Servers) Validate(formats strfmt.Registry) error

Validate validates this servers

type SetEnv ¶ 

type SetEnv struct {

	// name
	// Required: true
	Name *string `json:"name"`

	// value
	// Required: true
	Value *string `json:"value"`
}

SetEnv set env

swagger:model SetEnv

func (*SetEnv) ContextValidate ¶ 

func (m *SetEnv) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this set env based on context it is used

func (SetEnv) Diff ¶ added in v5.1.0 

func (s SetEnv) Diff(t SetEnv, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SetEnv are equal 

var a, b SetEnv
diff := a.Diff(b)

opts ...Options are ignored in this method

func (SetEnv) Equal ¶ added in v5.1.0 

func (s SetEnv) Equal(t SetEnv, opts ...Options) bool

Equal checks if two structs of type SetEnv are equal 

var a, b SetEnv
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*SetEnv) MarshalBinary ¶ 

func (m *SetEnv) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SetEnv) UnmarshalBinary ¶ 

func (m *SetEnv) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SetEnv) Validate ¶ 

func (m *SetEnv) Validate(formats strfmt.Registry) error

Validate validates this set env

type SetVar ¶ 

type SetVar struct {

	// expr
	// Required: true
	Expr *string `json:"expr"`

	// name
	// Required: true
	Name *string `json:"name"`
}

SetVar set var

swagger:model SetVar

func (*SetVar) ContextValidate ¶ 

func (m *SetVar) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this set var based on context it is used

func (SetVar) Diff ¶ added in v5.1.0 

func (s SetVar) Diff(t SetVar, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SetVar are equal 

var a, b SetVar
diff := a.Diff(b)

opts ...Options are ignored in this method

func (SetVar) Equal ¶ added in v5.1.0 

func (s SetVar) Equal(t SetVar, opts ...Options) bool

Equal checks if two structs of type SetVar are equal 

var a, b SetVar
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*SetVar) MarshalBinary ¶ 

func (m *SetVar) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SetVar) UnmarshalBinary ¶ 

func (m *SetVar) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SetVar) Validate ¶ 

func (m *SetVar) Validate(formats strfmt.Registry) error

Validate validates this set var

type SetVarFmt ¶ 

type SetVarFmt struct {

	// format
	// Required: true
	Format *string `json:"format"`

	// name
	// Required: true
	Name *string `json:"name"`
}

SetVarFmt set var fmt

swagger:model SetVarFmt

func (*SetVarFmt) ContextValidate ¶ 

func (m *SetVarFmt) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this set var fmt based on context it is used

func (SetVarFmt) Diff ¶ added in v5.1.0 

func (s SetVarFmt) Diff(t SetVarFmt, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SetVarFmt are equal 

var a, b SetVarFmt
diff := a.Diff(b)

opts ...Options are ignored in this method

func (SetVarFmt) Equal ¶ added in v5.1.0 

func (s SetVarFmt) Equal(t SetVarFmt, opts ...Options) bool

Equal checks if two structs of type SetVarFmt are equal 

var a, b SetVarFmt
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*SetVarFmt) MarshalBinary ¶ 

func (m *SetVarFmt) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SetVarFmt) UnmarshalBinary ¶ 

func (m *SetVarFmt) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SetVarFmt) Validate ¶ 

func (m *SetVarFmt) Validate(formats strfmt.Registry) error

Validate validates this set var fmt

type Site ¶ 

type Site struct {

	// farms
	Farms []*SiteFarm `json:"farms,omitempty"`

	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name string `json:"name"`

	// service
	Service *SiteService `json:"service,omitempty"`
}

Site Site

Site configuration. Sites are considered as one service and all farms connected to that service. Farms are connected to service using use-backend and default_backend directives. Sites let you configure simple HAProxy configurations, for more advanced options use /haproxy/configuration endpoints.

Example: {"farms":[{"balance":{"algorithm":"roundrobin"},"mode":"http","name":"www_backend","servers":[{"address":"127.0.1.1","name":"www_server","port":4567},{"address":"127.0.1.2","name":"www_server_new","port":4567}],"use_as":"default"}],"name":"test_site","service":{"http_connection_mode":"httpclose","maxconn":2000,"mode":"http"}}

swagger:model site

func (*Site) ContextValidate ¶ 

func (m *Site) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this site based on the context it is used

func (Site) Diff ¶ added in v5.1.0 

func (s Site) Diff(t Site, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Site are equal

By default empty maps and slices are equal to nil: 

var a, b Site
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Site
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Site) Equal ¶ added in v5.1.0 

func (s Site) Equal(t Site, opts ...Options) bool

Equal checks if two structs of type Site are equal

By default empty maps and slices are equal to nil: 

var a, b Site
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Site
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Site) MarshalBinary ¶ 

func (m *Site) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Site) UnmarshalBinary ¶ 

func (m *Site) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Site) Validate ¶ 

func (m *Site) Validate(formats strfmt.Registry) error

Validate validates this site

type SiteFarm ¶ 

type SiteFarm struct {

	// balance
	Balance *Balance `json:"balance,omitempty"`

	// cond
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond string `json:"cond,omitempty"`

	// cond test
	CondTest string `json:"cond_test,omitempty"`

	// forwardfor
	Forwardfor *Forwardfor `json:"forwardfor,omitempty"`

	// mode
	// Enum: [http tcp]
	// +kubebuilder:validation:Enum=http;tcp;
	Mode string `json:"mode,omitempty"`

	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name string `json:"name"`

	// servers
	Servers []*Server `json:"servers,omitempty"`

	// use as
	// Required: true
	// Enum: [default conditional]
	// +kubebuilder:validation:Enum=default;conditional;
	UseAs string `json:"use_as"`
}

SiteFarm site farm

swagger:model SiteFarm

func (*SiteFarm) ContextValidate ¶ 

func (m *SiteFarm) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this site farm based on the context it is used

func (SiteFarm) Diff ¶ added in v5.1.0 

func (s SiteFarm) Diff(t SiteFarm, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SiteFarm are equal

By default empty maps and slices are equal to nil: 

var a, b SiteFarm
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SiteFarm
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (SiteFarm) Equal ¶ added in v5.1.0 

func (s SiteFarm) Equal(t SiteFarm, opts ...Options) bool

Equal checks if two structs of type SiteFarm are equal

By default empty maps and slices are equal to nil: 

var a, b SiteFarm
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SiteFarm
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*SiteFarm) MarshalBinary ¶ 

func (m *SiteFarm) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SiteFarm) UnmarshalBinary ¶ 

func (m *SiteFarm) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SiteFarm) Validate ¶ 

func (m *SiteFarm) Validate(formats strfmt.Registry) error

Validate validates this site farm

type SiteService ¶ 

type SiteService struct {
	// http connection mode
	// Enum: [http-tunnel httpclose forced-close http-server-close http-keep-alive]
	// +kubebuilder:validation:Enum=http-tunnel;httpclose;forced-close;http-server-close;http-keep-alive;
	HTTPConnectionMode string `json:"http_connection_mode,omitempty"`

	// listeners
	Listeners []*Bind `json:"listeners,omitempty"`

	// maxconn
	Maxconn *int64 `json:"maxconn,omitempty"`

	// mode
	// Enum: [http tcp]
	// +kubebuilder:validation:Enum=http;tcp;
	Mode string `json:"mode,omitempty"`
}

SiteService site service

swagger:model SiteService

func (*SiteService) ContextValidate ¶ 

func (m *SiteService) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this site service based on the context it is used

func (SiteService) Diff ¶ added in v5.1.0 

func (s SiteService) Diff(t SiteService, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SiteService are equal

By default empty maps and slices are equal to nil: 

var a, b SiteService
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SiteService
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (SiteService) Equal ¶ added in v5.1.0 

func (s SiteService) Equal(t SiteService, opts ...Options) bool

Equal checks if two structs of type SiteService are equal

By default empty maps and slices are equal to nil: 

var a, b SiteService
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SiteService
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*SiteService) MarshalBinary ¶ 

func (m *SiteService) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SiteService) UnmarshalBinary ¶ 

func (m *SiteService) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SiteService) Validate ¶ 

func (m *SiteService) Validate(formats strfmt.Registry) error

Validate validates this site service

type Sites ¶ 

type Sites []*Site

Sites Sites

Sites array. Sites are considered as one service and all farms connected to that service. Farms are connected to service using use-backend and default_backend directives. Sites let you configure simple HAProxy configurations, for more advanced options use /haproxy/configuration endpoints.

swagger:model sites

func (Sites) ContextValidate ¶ 

func (m Sites) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this sites based on the context it is used

func (Sites) Diff ¶ added in v5.1.0 

func (s Sites) Diff(t Sites, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Sites are equal

By default empty maps and slices are equal to nil: 

var a, b Sites
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Sites
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Sites) Equal ¶ added in v5.1.0 

func (s Sites) Equal(t Sites, opts ...Options) bool

Equal checks if two structs of type Sites are equal

By default empty maps and slices are equal to nil: 

var a, b Sites
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Sites
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Sites) Validate ¶ 

func (m Sites) Validate(formats strfmt.Registry) error

Validate validates this sites

type SmtpchkParams ¶ 

type SmtpchkParams struct {

	// domain
	Domain string `json:"domain,omitempty"`

	// hello
	Hello string `json:"hello,omitempty"`
}

SmtpchkParams smtpchk params

swagger:model smtpchk_params

func (*SmtpchkParams) ContextValidate ¶ 

func (m *SmtpchkParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this smtpchk params based on context it is used

func (SmtpchkParams) Diff ¶ added in v5.1.0 

func (s SmtpchkParams) Diff(t SmtpchkParams, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SmtpchkParams are equal 

var a, b SmtpchkParams
diff := a.Diff(b)

opts ...Options are ignored in this method

func (SmtpchkParams) Equal ¶ added in v5.1.0 

func (s SmtpchkParams) Equal(t SmtpchkParams, opts ...Options) bool

Equal checks if two structs of type SmtpchkParams are equal 

var a, b SmtpchkParams
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*SmtpchkParams) MarshalBinary ¶ 

func (m *SmtpchkParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SmtpchkParams) UnmarshalBinary ¶ 

func (m *SmtpchkParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SmtpchkParams) Validate ¶ 

func (m *SmtpchkParams) Validate(formats strfmt.Registry) error

Validate validates this smtpchk params

type Source ¶ 

type Source struct {

	// address
	// Required: true
	Address *string `json:"address"`

	// address second
	AddressSecond string `json:"address_second,omitempty"`

	// hdr
	Hdr string `json:"hdr,omitempty"`

	// interface
	Interface string `json:"interface,omitempty"`

	// occ
	Occ string `json:"occ,omitempty"`

	// port
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port int64 `json:"port,omitempty"`

	// port second
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	PortSecond int64 `json:"port_second,omitempty"`

	// usesrc
	// Enum: [address client clientip hdr_ip]
	// +kubebuilder:validation:Enum=address;client;clientip;hdr_ip;
	Usesrc string `json:"usesrc,omitempty"`
}

Source source

swagger:model source

func (*Source) ContextValidate ¶ 

func (m *Source) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this source based on context it is used

func (Source) Diff ¶ added in v5.1.0 

func (s Source) Diff(t Source, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Source are equal 

var a, b Source
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Source) Equal ¶ added in v5.1.0 

func (s Source) Equal(t Source, opts ...Options) bool

Equal checks if two structs of type Source are equal 

var a, b Source
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Source) MarshalBinary ¶ 

func (m *Source) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Source) UnmarshalBinary ¶ 

func (m *Source) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Source) Validate ¶ 

func (m *Source) Validate(formats strfmt.Registry) error

Validate validates this source

type SpoeAgent ¶ 

type SpoeAgent struct {
	// async
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Async string `json:"async,omitempty"`

	// continue on error
	// Enum: [enabled]
	// +kubebuilder:validation:Enum=enabled;
	ContinueOnError string `json:"continue-on-error,omitempty"`

	// dontlog normal
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	DontlogNormal string `json:"dontlog-normal,omitempty"`

	// engine name
	EngineName string `json:"engine-name,omitempty"`

	// force set var
	// Enum: [enabled]
	// +kubebuilder:validation:Enum=enabled;
	ForceSetVar string `json:"force-set-var,omitempty"`

	// groups
	Groups string `json:"groups,omitempty"`

	// hello timeout
	HelloTimeout int64 `json:"hello_timeout,omitempty"`

	// idle timeout
	IdleTimeout int64 `json:"idle_timeout,omitempty"`

	// log
	Log LogTargets `json:"log,omitempty"`

	// max frame size
	MaxFrameSize int64 `json:"max-frame-size,omitempty"`

	// max waiting frames
	MaxWaitingFrames int64 `json:"max-waiting-frames,omitempty"`

	// maxconnrate
	Maxconnrate int64 `json:"maxconnrate,omitempty"`

	// maxerrrate
	Maxerrrate int64 `json:"maxerrrate,omitempty"`

	// messages
	Messages string `json:"messages,omitempty"`

	// name
	// Required: true
	Name *string `json:"name"`

	// option set on error
	// Pattern: ^[A-Za-z0-9-_.]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.]+$`
	OptionSetOnError string `json:"option_set-on-error,omitempty"`

	// option set process time
	// Pattern: ^[A-Za-z0-9-_.]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.]+$`
	OptionSetProcessTime string `json:"option_set-process-time,omitempty"`

	// option set total time
	// Pattern: ^[A-Za-z0-9-_.]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.]+$`
	OptionSetTotalTime string `json:"option_set-total-time,omitempty"`

	// option var prefix
	// Pattern: ^[A-Za-z0-9-_.]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.]+$`
	OptionVarPrefix string `json:"option_var-prefix,omitempty"`

	// pipelining
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	Pipelining string `json:"pipelining,omitempty"`

	// processing timeout
	ProcessingTimeout int64 `json:"processing_timeout,omitempty"`

	// register var names
	RegisterVarNames string `json:"register-var-names,omitempty"`

	// send frag payload
	// Enum: [enabled disabled]
	// +kubebuilder:validation:Enum=enabled;disabled;
	SendFragPayload string `json:"send-frag-payload,omitempty"`

	// use backend
	UseBackend string `json:"use-backend,omitempty"`
}

SpoeAgent SPOE agent

SPOE agent configuration ¶

swagger:model spoe_agent

func (*SpoeAgent) ContextValidate ¶ 

func (m *SpoeAgent) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this spoe agent based on the context it is used

func (SpoeAgent) Diff ¶ added in v5.1.0 

func (s SpoeAgent) Diff(t SpoeAgent, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SpoeAgent are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeAgent
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeAgent
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (SpoeAgent) Equal ¶ added in v5.1.0 

func (s SpoeAgent) Equal(t SpoeAgent, opts ...Options) bool

Equal checks if two structs of type SpoeAgent are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeAgent
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeAgent
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*SpoeAgent) MarshalBinary ¶ 

func (m *SpoeAgent) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SpoeAgent) UnmarshalBinary ¶ 

func (m *SpoeAgent) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SpoeAgent) Validate ¶ 

func (m *SpoeAgent) Validate(formats strfmt.Registry) error

Validate validates this spoe agent

type SpoeAgents ¶ 

type SpoeAgents []*SpoeAgent

SpoeAgents SPOE Agents

SPOE Agents of one scope in SPOE file ¶

swagger:model spoe_agents

func (SpoeAgents) ContextValidate ¶ 

func (m SpoeAgents) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this spoe agents based on the context it is used

func (SpoeAgents) Diff ¶ added in v5.1.0 

func (s SpoeAgents) Diff(t SpoeAgents, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SpoeAgents are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeAgents
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeAgents
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (SpoeAgents) Equal ¶ added in v5.1.0 

func (s SpoeAgents) Equal(t SpoeAgents, opts ...Options) bool

Equal checks if two structs of type SpoeAgents are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeAgents
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeAgents
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (SpoeAgents) Validate ¶ 

func (m SpoeAgents) Validate(formats strfmt.Registry) error

Validate validates this spoe agents

type SpoeFiles ¶ 

type SpoeFiles []string

SpoeFiles SPOE files

SPOE files ¶

swagger:model spoe_files

func (SpoeFiles) ContextValidate ¶ 

func (m SpoeFiles) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this spoe files based on context it is used

func (SpoeFiles) Diff ¶ added in v5.1.0 

func (s SpoeFiles) Diff(t SpoeFiles, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SpoeFiles are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeFiles
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeFiles
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (SpoeFiles) Equal ¶ added in v5.1.0 

func (s SpoeFiles) Equal(t SpoeFiles, opts ...Options) bool

Equal checks if two structs of type SpoeFiles are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeFiles
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeFiles
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (SpoeFiles) Validate ¶ 

func (m SpoeFiles) Validate(formats strfmt.Registry) error

Validate validates this spoe files

type SpoeGroup ¶ 

type SpoeGroup struct {

	// messages
	Messages string `json:"messages,omitempty"`

	// name
	// Required: true
	Name *string `json:"name"`
}

SpoeGroup SPOE group

SPOE group section configuration ¶

swagger:model spoe_group

func (*SpoeGroup) ContextValidate ¶ 

func (m *SpoeGroup) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this spoe group based on context it is used

func (SpoeGroup) Diff ¶ added in v5.1.0 

func (s SpoeGroup) Diff(t SpoeGroup, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SpoeGroup are equal 

var a, b SpoeGroup
diff := a.Diff(b)

opts ...Options are ignored in this method

func (SpoeGroup) Equal ¶ added in v5.1.0 

func (s SpoeGroup) Equal(t SpoeGroup, opts ...Options) bool

Equal checks if two structs of type SpoeGroup are equal 

var a, b SpoeGroup
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*SpoeGroup) MarshalBinary ¶ 

func (m *SpoeGroup) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SpoeGroup) UnmarshalBinary ¶ 

func (m *SpoeGroup) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SpoeGroup) Validate ¶ 

func (m *SpoeGroup) Validate(formats strfmt.Registry) error

Validate validates this spoe group

type SpoeGroups ¶ 

type SpoeGroups []*SpoeGroup

SpoeGroups SPOE Groups

SPOE Groups of one scope in SPOE file ¶

swagger:model spoe_groups

func (SpoeGroups) ContextValidate ¶ 

func (m SpoeGroups) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this spoe groups based on the context it is used

func (SpoeGroups) Diff ¶ added in v5.1.0 

func (s SpoeGroups) Diff(t SpoeGroups, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SpoeGroups are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeGroups
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeGroups
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (SpoeGroups) Equal ¶ added in v5.1.0 

func (s SpoeGroups) Equal(t SpoeGroups, opts ...Options) bool

Equal checks if two structs of type SpoeGroups are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeGroups
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeGroups
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (SpoeGroups) Validate ¶ 

func (m SpoeGroups) Validate(formats strfmt.Registry) error

Validate validates this spoe groups

type SpoeMessage ¶ 

type SpoeMessage struct {

	// acl
	ACL Acls `json:"acl,omitempty"`

	// args
	Args string `json:"args,omitempty"`

	// event
	Event *SpoeMessageEvent `json:"event,omitempty"`

	// name
	// Required: true
	Name *string `json:"name"`
}

SpoeMessage SPOE message

SPOE message section configuration ¶

swagger:model spoe_message

func (*SpoeMessage) ContextValidate ¶ 

func (m *SpoeMessage) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this spoe message based on the context it is used

func (SpoeMessage) Diff ¶ added in v5.1.0 

func (s SpoeMessage) Diff(t SpoeMessage, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SpoeMessage are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeMessage
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeMessage
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (SpoeMessage) Equal ¶ added in v5.1.0 

func (s SpoeMessage) Equal(t SpoeMessage, opts ...Options) bool

Equal checks if two structs of type SpoeMessage are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeMessage
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeMessage
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*SpoeMessage) MarshalBinary ¶ 

func (m *SpoeMessage) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SpoeMessage) UnmarshalBinary ¶ 

func (m *SpoeMessage) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SpoeMessage) Validate ¶ 

func (m *SpoeMessage) Validate(formats strfmt.Registry) error

Validate validates this spoe message

type SpoeMessageEvent ¶ 

type SpoeMessageEvent struct {
	// cond
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond string `json:"cond,omitempty"`

	// cond test
	CondTest string `json:"cond_test,omitempty"`

	// name
	// Required: true
	// Enum: [on-backend-http-request on-backend-tcp-request on-client-session on-frontend-http-request on-frontend-tcp-request on-http-response on-server-session on-tcp-response]
	// +kubebuilder:validation:Enum=on-backend-http-request;on-backend-tcp-request;on-client-session;on-frontend-http-request;on-frontend-tcp-request;on-http-response;on-server-session;on-tcp-response;
	Name *string `json:"name"`
}

SpoeMessageEvent spoe message event

swagger:model SpoeMessageEvent

func (*SpoeMessageEvent) ContextValidate ¶ 

func (m *SpoeMessageEvent) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this spoe message event based on context it is used

func (SpoeMessageEvent) Diff ¶ added in v5.1.0 

func (s SpoeMessageEvent) Diff(t SpoeMessageEvent, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SpoeMessageEvent are equal 

var a, b SpoeMessageEvent
diff := a.Diff(b)

opts ...Options are ignored in this method

func (SpoeMessageEvent) Equal ¶ added in v5.1.0 

func (s SpoeMessageEvent) Equal(t SpoeMessageEvent, opts ...Options) bool

Equal checks if two structs of type SpoeMessageEvent are equal 

var a, b SpoeMessageEvent
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*SpoeMessageEvent) MarshalBinary ¶ 

func (m *SpoeMessageEvent) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SpoeMessageEvent) UnmarshalBinary ¶ 

func (m *SpoeMessageEvent) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SpoeMessageEvent) Validate ¶ 

func (m *SpoeMessageEvent) Validate(formats strfmt.Registry) error

Validate validates this spoe message event

type SpoeMessages ¶ 

type SpoeMessages []*SpoeMessage

SpoeMessages SPOE Messages

SPOE Messages of one scope in SPOE file ¶

swagger:model spoe_messages

func (SpoeMessages) ContextValidate ¶ 

func (m SpoeMessages) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this spoe messages based on the context it is used

func (SpoeMessages) Diff ¶ added in v5.1.0 

func (s SpoeMessages) Diff(t SpoeMessages, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SpoeMessages are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeMessages
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeMessages
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (SpoeMessages) Equal ¶ added in v5.1.0 

func (s SpoeMessages) Equal(t SpoeMessages, opts ...Options) bool

Equal checks if two structs of type SpoeMessages are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeMessages
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeMessages
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (SpoeMessages) Validate ¶ 

func (m SpoeMessages) Validate(formats strfmt.Registry) error

Validate validates this spoe messages

type SpoeScope ¶ 

type SpoeScope string

SpoeScope SPOE scope

SPOE scope name ¶

swagger:model spoe_scope

func (SpoeScope) ContextValidate ¶ 

func (m SpoeScope) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this spoe scope based on context it is used

func (SpoeScope) Diff ¶ added in v5.1.0 

func (s SpoeScope) Diff(t SpoeScope, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SpoeScope are equal 

var a, b SpoeScope
diff := a.Diff(b)

opts ...Options are ignored in this method

func (SpoeScope) Equal ¶ added in v5.1.0 

func (s SpoeScope) Equal(t SpoeScope, opts ...Options) bool

Equal checks if two structs of type SpoeScope are equal 

var a, b SpoeScope
equal := a.Equal(b)

opts ...Options are ignored in this method

func (SpoeScope) Validate ¶ 

func (m SpoeScope) Validate(formats strfmt.Registry) error

Validate validates this spoe scope

type SpoeScopes ¶ 

type SpoeScopes []SpoeScope

SpoeScopes SPOE Scopes

All SPOE Scopes ¶

swagger:model spoe_scopes

func (SpoeScopes) ContextValidate ¶ 

func (m SpoeScopes) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this spoe scopes based on the context it is used

func (SpoeScopes) Diff ¶ added in v5.1.0 

func (s SpoeScopes) Diff(t SpoeScopes, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SpoeScopes are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeScopes
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeScopes
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (SpoeScopes) Equal ¶ added in v5.1.0 

func (s SpoeScopes) Equal(t SpoeScopes, opts ...Options) bool

Equal checks if two structs of type SpoeScopes are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeScopes
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeScopes
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (SpoeScopes) Validate ¶ 

func (m SpoeScopes) Validate(formats strfmt.Registry) error

Validate validates this spoe scopes

type SpoeTransaction ¶ 

type SpoeTransaction struct {

	// version
	Version int64 `json:"_version,omitempty"`

	// id
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ID string `json:"id,omitempty"`

	// status
	// Enum: [failed in_progress success]
	// +kubebuilder:validation:Enum=failed;in_progress;success;
	Status string `json:"status,omitempty"`
}

SpoeTransaction SPOE configuration transaction

SPOE configuration transaction Example: {"_version":2,"id":"273e3385-2d0c-4fb1-aa27-93cbb31ff203","status":"in_progress"}

swagger:model spoe_transaction

func (*SpoeTransaction) ContextValidate ¶ 

func (m *SpoeTransaction) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this spoe transaction based on context it is used

func (SpoeTransaction) Diff ¶ added in v5.1.0 

func (s SpoeTransaction) Diff(t SpoeTransaction, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SpoeTransaction are equal 

var a, b SpoeTransaction
diff := a.Diff(b)

opts ...Options are ignored in this method

func (SpoeTransaction) Equal ¶ added in v5.1.0 

func (s SpoeTransaction) Equal(t SpoeTransaction, opts ...Options) bool

Equal checks if two structs of type SpoeTransaction are equal 

var a, b SpoeTransaction
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*SpoeTransaction) MarshalBinary ¶ 

func (m *SpoeTransaction) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SpoeTransaction) UnmarshalBinary ¶ 

func (m *SpoeTransaction) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SpoeTransaction) Validate ¶ 

func (m *SpoeTransaction) Validate(formats strfmt.Registry) error

Validate validates this spoe transaction

type SpoeTransactions ¶ 

type SpoeTransactions []*SpoeTransaction

SpoeTransactions SPOE Transactions array

SPOE Configuration transactions array ¶

swagger:model spoe_transactions

func (SpoeTransactions) ContextValidate ¶ 

func (m SpoeTransactions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this spoe transactions based on the context it is used

func (SpoeTransactions) Diff ¶ added in v5.1.0 

func (s SpoeTransactions) Diff(t SpoeTransactions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SpoeTransactions are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeTransactions
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeTransactions
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (SpoeTransactions) Equal ¶ added in v5.1.0 

func (s SpoeTransactions) Equal(t SpoeTransactions, opts ...Options) bool

Equal checks if two structs of type SpoeTransactions are equal

By default empty maps and slices are equal to nil: 

var a, b SpoeTransactions
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SpoeTransactions
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (SpoeTransactions) Validate ¶ 

func (m SpoeTransactions) Validate(formats strfmt.Registry) error

Validate validates this spoe transactions

type SslCertEntry ¶ 

type SslCertEntry struct {

	// algorithm
	Algorithm string `json:"algorithm,omitempty"`

	// chain issuer
	ChainIssuer string `json:"chain_issuer,omitempty"`

	// chain subject
	ChainSubject string `json:"chain_subject,omitempty"`

	// issuer
	Issuer string `json:"issuer,omitempty"`

	// not after
	// Format: date
	// +kubebuilder:validation:Format=date
	NotAfter strfmt.Date `json:"not_after,omitempty"`

	// not before
	// Format: date
	// +kubebuilder:validation:Format=date
	NotBefore strfmt.Date `json:"not_before,omitempty"`

	// serial
	Serial string `json:"serial,omitempty"`

	// sha1 finger print
	Sha1FingerPrint string `json:"sha1_finger_print,omitempty"`

	// status
	Status string `json:"status,omitempty"`

	// storage name
	StorageName string `json:"storage_name,omitempty"`

	// subject
	Subject string `json:"subject,omitempty"`

	// subject alternative names
	SubjectAlternativeNames []string `json:"subject_alternative_names,omitempty"`
}

SslCertEntry One SSL Certificate Entry

One SSL/TLS certificate

swagger:model ssl_cert_entry

func (*SslCertEntry) ContextValidate ¶ 

func (m *SslCertEntry) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this ssl cert entry based on context it is used

func (SslCertEntry) Diff ¶ added in v5.1.0 

func (s SslCertEntry) Diff(t SslCertEntry, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SslCertEntry are equal

By default empty maps and slices are equal to nil: 

var a, b SslCertEntry
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SslCertEntry
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (SslCertEntry) Equal ¶ added in v5.1.0 

func (s SslCertEntry) Equal(t SslCertEntry, opts ...Options) bool

Equal checks if two structs of type SslCertEntry are equal

By default empty maps and slices are equal to nil: 

var a, b SslCertEntry
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SslCertEntry
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*SslCertEntry) MarshalBinary ¶ 

func (m *SslCertEntry) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SslCertEntry) UnmarshalBinary ¶ 

func (m *SslCertEntry) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SslCertEntry) Validate ¶ 

func (m *SslCertEntry) Validate(formats strfmt.Registry) error

Validate validates this ssl cert entry

type SslCertificate ¶ 

type SslCertificate struct {

	// description
	Description string `json:"description,omitempty"`

	// domains
	// Read Only: true
	Domains string `json:"domains,omitempty"`

	// file
	File string `json:"file,omitempty"`

	// ip addresses
	// Read Only: true
	IPAddresses string `json:"ip_addresses,omitempty"`

	// issuers
	// Read Only: true
	Issuers string `json:"issuers,omitempty"`

	// not after
	// Read Only: true
	// Format: date-time
	// +kubebuilder:validation:Format=date-time
	NotAfter *strfmt.DateTime `json:"not_after,omitempty" gorm:"type:timestamp with time zone"`

	// not before
	// Read Only: true
	// Format: date-time
	// +kubebuilder:validation:Format=date-time
	NotBefore *strfmt.DateTime `json:"not_before,omitempty" gorm:"type:timestamp with time zone"`

	// File size in bytes.
	// Read Only: true
	Size *int64 `json:"size,omitempty"`

	// storage name
	StorageName string `json:"storage_name,omitempty"`
}

SslCertificate SSL File

A file containing one or more SSL/TLS certificates and keys

swagger:model ssl_certificate

func (*SslCertificate) ContextValidate ¶ 

func (m *SslCertificate) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this ssl certificate based on the context it is used

func (SslCertificate) Diff ¶ added in v5.1.0 

func (s SslCertificate) Diff(t SslCertificate, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SslCertificate are equal

By default empty maps and slices are equal to nil: 

var a, b SslCertificate
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SslCertificate
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (SslCertificate) Equal ¶ added in v5.1.0 

func (s SslCertificate) Equal(t SslCertificate, opts ...Options) bool

Equal checks if two structs of type SslCertificate are equal

By default empty maps and slices are equal to nil: 

var a, b SslCertificate
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SslCertificate
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*SslCertificate) MarshalBinary ¶ 

func (m *SslCertificate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SslCertificate) UnmarshalBinary ¶ 

func (m *SslCertificate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SslCertificate) Validate ¶ 

func (m *SslCertificate) Validate(formats strfmt.Registry) error

Validate validates this ssl certificate

type SslCertificates ¶ 

type SslCertificates []*SslCertificate

SslCertificates SSL Files Array

Array of ssl certificate files ¶

swagger:model ssl_certificates

func (SslCertificates) ContextValidate ¶ 

func (m SslCertificates) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this ssl certificates based on the context it is used

func (SslCertificates) Diff ¶ added in v5.1.0 

func (s SslCertificates) Diff(t SslCertificates, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SslCertificates are equal

By default empty maps and slices are equal to nil: 

var a, b SslCertificates
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SslCertificates
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (SslCertificates) Equal ¶ added in v5.1.0 

func (s SslCertificates) Equal(t SslCertificates, opts ...Options) bool

Equal checks if two structs of type SslCertificates are equal

By default empty maps and slices are equal to nil: 

var a, b SslCertificates
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SslCertificates
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (SslCertificates) Validate ¶ 

func (m SslCertificates) Validate(formats strfmt.Registry) error

Validate validates this ssl certificates

type SslEngine ¶ 

type SslEngine struct {

	// algorithms
	Algorithms *string `json:"algorithms,omitempty"`

	// name
	// Required: true
	Name *string `json:"name"`
}

SslEngine ssl engine

swagger:model SslEngine

func (*SslEngine) ContextValidate ¶ 

func (m *SslEngine) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this ssl engine based on context it is used

func (SslEngine) Diff ¶ added in v5.1.0 

func (s SslEngine) Diff(t SslEngine, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SslEngine are equal 

var a, b SslEngine
diff := a.Diff(b)

opts ...Options are ignored in this method

func (SslEngine) Equal ¶ added in v5.1.0 

func (s SslEngine) Equal(t SslEngine, opts ...Options) bool

Equal checks if two structs of type SslEngine are equal 

var a, b SslEngine
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*SslEngine) MarshalBinary ¶ 

func (m *SslEngine) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SslEngine) UnmarshalBinary ¶ 

func (m *SslEngine) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SslEngine) Validate ¶ 

func (m *SslEngine) Validate(formats strfmt.Registry) error

Validate validates this ssl engine

type StatsAuth ¶ 

type StatsAuth struct {

	// passwd
	// Required: true
	Passwd *string `json:"passwd"`

	// user
	// Required: true
	User *string `json:"user"`
}

StatsAuth stats auth

swagger:model stats_auth

func (*StatsAuth) ContextValidate ¶ 

func (m *StatsAuth) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this stats auth based on context it is used

func (StatsAuth) Diff ¶ added in v5.1.0 

func (s StatsAuth) Diff(t StatsAuth, opts ...Options) map[string][]interface{}

Diff checks if two structs of type StatsAuth are equal 

var a, b StatsAuth
diff := a.Diff(b)

opts ...Options are ignored in this method

func (StatsAuth) Equal ¶ added in v5.1.0 

func (s StatsAuth) Equal(t StatsAuth, opts ...Options) bool

Equal checks if two structs of type StatsAuth are equal 

var a, b StatsAuth
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*StatsAuth) MarshalBinary ¶ 

func (m *StatsAuth) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*StatsAuth) UnmarshalBinary ¶ 

func (m *StatsAuth) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*StatsAuth) Validate ¶ 

func (m *StatsAuth) Validate(formats strfmt.Registry) error

Validate validates this stats auth

type StatsHTTPRequest ¶ 

type StatsHTTPRequest struct {

	// cond
	Cond string `json:"cond,omitempty"`

	// cond test
	CondTest string `json:"cond_test,omitempty"`

	// realm
	Realm string `json:"realm,omitempty"`

	// type
	// Required: true
	// Enum: [allow deny auth]
	// +kubebuilder:validation:Enum=allow;deny;auth;
	Type *string `json:"type"`
}

StatsHTTPRequest stats http request

swagger:model stats_http_request

func (*StatsHTTPRequest) ContextValidate ¶ 

func (m *StatsHTTPRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this stats http request based on context it is used

func (StatsHTTPRequest) Diff ¶ added in v5.1.0 

func (s StatsHTTPRequest) Diff(t StatsHTTPRequest, opts ...Options) map[string][]interface{}

Diff checks if two structs of type StatsHTTPRequest are equal 

var a, b StatsHTTPRequest
diff := a.Diff(b)

opts ...Options are ignored in this method

func (StatsHTTPRequest) Equal ¶ added in v5.1.0 

func (s StatsHTTPRequest) Equal(t StatsHTTPRequest, opts ...Options) bool

Equal checks if two structs of type StatsHTTPRequest are equal 

var a, b StatsHTTPRequest
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*StatsHTTPRequest) MarshalBinary ¶ 

func (m *StatsHTTPRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*StatsHTTPRequest) UnmarshalBinary ¶ 

func (m *StatsHTTPRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*StatsHTTPRequest) Validate ¶ 

func (m *StatsHTTPRequest) Validate(formats strfmt.Registry) error

Validate validates this stats http request

type StatsOptions ¶ 

type StatsOptions struct {

	// stats admin
	StatsAdmin bool `json:"stats_admin,omitempty"`

	// stats admin cond
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	StatsAdminCond string `json:"stats_admin_cond,omitempty"`

	// stats admin cond test
	StatsAdminCondTest string `json:"stats_admin_cond_test,omitempty"`

	// stats auths
	StatsAuths []*StatsAuth `json:"stats_auths,omitempty"`

	// stats enable
	StatsEnable bool `json:"stats_enable,omitempty"`

	// stats hide version
	StatsHideVersion bool `json:"stats_hide_version,omitempty"`

	// stats http requests
	StatsHTTPRequests []*StatsHTTPRequest `json:"stats_http_requests,omitempty"`

	// stats maxconn
	// Minimum: 1
	// +kubebuilder:validation:Minimum=1
	StatsMaxconn int64 `json:"stats_maxconn,omitempty"`

	// stats realm
	StatsRealm bool `json:"stats_realm,omitempty"`

	// stats realm realm
	StatsRealmRealm *string `json:"stats_realm_realm,omitempty"`

	// stats refresh delay
	StatsRefreshDelay *int64 `json:"stats_refresh_delay,omitempty"`

	// stats show desc
	StatsShowDesc *string `json:"stats_show_desc,omitempty"`

	// stats show legends
	StatsShowLegends bool `json:"stats_show_legends,omitempty"`

	// stats show modules
	StatsShowModules bool `json:"stats_show_modules,omitempty"`

	// stats show node name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	StatsShowNodeName *string `json:"stats_show_node_name"`

	// stats uri prefix
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	StatsURIPrefix string `json:"stats_uri_prefix,omitempty"`
}

StatsOptions stats options

swagger:model stats_options

func (*StatsOptions) ContextValidate ¶ 

func (m *StatsOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this stats options based on the context it is used

func (StatsOptions) Diff ¶ added in v5.1.0 

func (s StatsOptions) Diff(t StatsOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type StatsOptions are equal

By default empty maps and slices are equal to nil: 

var a, b StatsOptions
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b StatsOptions
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (StatsOptions) Equal ¶ added in v5.1.0 

func (s StatsOptions) Equal(t StatsOptions, opts ...Options) bool

Equal checks if two structs of type StatsOptions are equal

By default empty maps and slices are equal to nil: 

var a, b StatsOptions
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b StatsOptions
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*StatsOptions) MarshalBinary ¶ 

func (m *StatsOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*StatsOptions) UnmarshalBinary ¶ 

func (m *StatsOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*StatsOptions) Validate ¶ 

func (m *StatsOptions) Validate(formats strfmt.Registry) error

Validate validates this stats options

type StickRule ¶ 

type StickRule struct {
	// cond
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond string `json:"cond,omitempty"`

	// cond test
	CondTest string `json:"cond_test,omitempty"`

	// index
	// Required: true
	// +kubebuilder:validation:Optional
	Index *int64 `json:"index"`

	// pattern
	// Required: true
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Pattern string `json:"pattern"`

	// table
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Table string `json:"table,omitempty"`

	// type
	// Required: true
	// Enum: [match on store-request store-response]
	// +kubebuilder:validation:Enum=match;on;store-request;store-response;
	Type string `json:"type"`
}

StickRule Stick Rule

Define a pattern used to create an entry in a stickiness table or matching condition or associate a user to a server. Example: {"index":0,"pattern":"src","type":"match"}

swagger:model stick_rule

func (*StickRule) ContextValidate ¶ 

func (m *StickRule) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this stick rule based on context it is used

func (StickRule) Diff ¶ added in v5.1.0 

func (s StickRule) Diff(t StickRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type StickRule are equal

By default empty maps and slices are equal to nil: 

var a, b StickRule
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b StickRule
diff := a.Diff(b,Options{
	SkipIndex: true,
})

func (StickRule) Equal ¶ added in v5.1.0 

func (s StickRule) Equal(t StickRule, opts ...Options) bool

Equal checks if two structs of type StickRule are equal

By default empty maps and slices are equal to nil: 

var a, b StickRule
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b StickRule
equal := a.Equal(b,Options{
	SkipIndex: true,
})

func (*StickRule) MarshalBinary ¶ 

func (m *StickRule) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*StickRule) UnmarshalBinary ¶ 

func (m *StickRule) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*StickRule) Validate ¶ 

func (m *StickRule) Validate(formats strfmt.Registry) error

Validate validates this stick rule

type StickRules ¶ 

type StickRules []*StickRule

StickRules Stick Rules Array

HAProxy backend stick rules array (corresponds to stick store-request, stick match, stick on, stick store-response)

swagger:model stick_rules

func (StickRules) ContextValidate ¶ 

func (m StickRules) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this stick rules based on the context it is used

func (StickRules) Diff ¶ added in v5.1.0 

func (s StickRules) Diff(t StickRules, opts ...Options) map[string][]interface{}

Diff checks if two structs of type StickRules are equal

By default empty maps and slices are equal to nil: 

var a, b StickRules
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b StickRules
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (StickRules) Equal ¶ added in v5.1.0 

func (s StickRules) Equal(t StickRules, opts ...Options) bool

Equal checks if two structs of type StickRules are equal

By default empty maps and slices are equal to nil: 

var a, b StickRules
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b StickRules
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (StickRules) Validate ¶ 

func (m StickRules) Validate(formats strfmt.Registry) error

Validate validates this stick rules

type StickTable ¶ 

type StickTable struct {

	// fields
	Fields []*StickTableField `json:"fields,omitempty"`

	// name
	Name string `json:"name,omitempty"`

	// Process number if master-worker mode
	Process *int64 `json:"process,omitempty"`

	// size
	Size *int64 `json:"size,omitempty"`

	// type
	// Enum: [ip ipv6 integer string binary]
	// +kubebuilder:validation:Enum=ip;ipv6;integer;string;binary;
	Type string `json:"type,omitempty"`

	// used
	Used *int64 `json:"used,omitempty"`
}

StickTable Stick Table

Stick Table Information ¶

swagger:model stick_table

func (*StickTable) ContextValidate ¶ 

func (m *StickTable) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this stick table based on the context it is used

func (StickTable) Diff ¶ added in v5.1.0 

func (s StickTable) Diff(t StickTable, opts ...Options) map[string][]interface{}

Diff checks if two structs of type StickTable are equal

By default empty maps and slices are equal to nil: 

var a, b StickTable
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b StickTable
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (StickTable) Equal ¶ added in v5.1.0 

func (s StickTable) Equal(t StickTable, opts ...Options) bool

Equal checks if two structs of type StickTable are equal

By default empty maps and slices are equal to nil: 

var a, b StickTable
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b StickTable
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*StickTable) MarshalBinary ¶ 

func (m *StickTable) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*StickTable) UnmarshalBinary ¶ 

func (m *StickTable) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*StickTable) Validate ¶ 

func (m *StickTable) Validate(formats strfmt.Registry) error

Validate validates this stick table

type StickTableEntries ¶ 

type StickTableEntries []*StickTableEntry

StickTableEntries Stick Tables Entries

Entries of one runtime stick table ¶

swagger:model stick_table_entries

func (StickTableEntries) ContextValidate ¶ 

func (m StickTableEntries) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this stick table entries based on the context it is used

func (StickTableEntries) Diff ¶ added in v5.1.0 

func (s StickTableEntries) Diff(t StickTableEntries, opts ...Options) map[string][]interface{}

Diff checks if two structs of type StickTableEntries are equal

By default empty maps and slices are equal to nil: 

var a, b StickTableEntries
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b StickTableEntries
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (StickTableEntries) Equal ¶ added in v5.1.0 

func (s StickTableEntries) Equal(t StickTableEntries, opts ...Options) bool

Equal checks if two structs of type StickTableEntries are equal

By default empty maps and slices are equal to nil: 

var a, b StickTableEntries
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b StickTableEntries
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (StickTableEntries) Validate ¶ 

func (m StickTableEntries) Validate(formats strfmt.Registry) error

Validate validates this stick table entries

type StickTableEntry ¶ 

type StickTableEntry struct {

	// bytes in cnt
	BytesInCnt *int64 `json:"bytes_in_cnt,omitempty"`

	// bytes in rate
	BytesInRate *int64 `json:"bytes_in_rate,omitempty"`

	// bytes out cnt
	BytesOutCnt *int64 `json:"bytes_out_cnt,omitempty"`

	// bytes out rate
	BytesOutRate *int64 `json:"bytes_out_rate,omitempty"`

	// conn cnt
	ConnCnt *int64 `json:"conn_cnt,omitempty"`

	// conn cur
	ConnCur *int64 `json:"conn_cur,omitempty"`

	// conn rate
	ConnRate *int64 `json:"conn_rate,omitempty"`

	// exp
	Exp *int64 `json:"exp,omitempty"`

	// gpc0
	Gpc0 *int64 `json:"gpc0,omitempty"`

	// gpc0 rate
	Gpc0Rate *int64 `json:"gpc0_rate,omitempty"`

	// gpc1
	Gpc1 *int64 `json:"gpc1,omitempty"`

	// gpc1 rate
	Gpc1Rate *int64 `json:"gpc1_rate,omitempty"`

	// gpt0
	Gpt0 *int64 `json:"gpt0,omitempty"`

	// http err cnt
	HTTPErrCnt *int64 `json:"http_err_cnt,omitempty"`

	// http err rate
	HTTPErrRate *int64 `json:"http_err_rate,omitempty"`

	// http req cnt
	HTTPReqCnt *int64 `json:"http_req_cnt,omitempty"`

	// http req rate
	HTTPReqRate *int64 `json:"http_req_rate,omitempty"`

	// id
	ID string `json:"id,omitempty"`

	// key
	Key string `json:"key,omitempty"`

	// server id
	ServerID *int64 `json:"server_id,omitempty"`

	// sess cnt
	SessCnt *int64 `json:"sess_cnt,omitempty"`

	// sess rate
	SessRate *int64 `json:"sess_rate,omitempty"`

	// use
	Use bool `json:"use,omitempty"`
}

StickTableEntry Stick Table Entry

One entry in stick table ¶

swagger:model stick_table_entry

func (*StickTableEntry) ContextValidate ¶ 

func (m *StickTableEntry) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this stick table entry based on context it is used

func (StickTableEntry) Diff ¶ added in v5.1.0 

func (s StickTableEntry) Diff(t StickTableEntry, opts ...Options) map[string][]interface{}

Diff checks if two structs of type StickTableEntry are equal 

var a, b StickTableEntry
diff := a.Diff(b)

opts ...Options are ignored in this method

func (StickTableEntry) Equal ¶ added in v5.1.0 

func (s StickTableEntry) Equal(t StickTableEntry, opts ...Options) bool

Equal checks if two structs of type StickTableEntry are equal 

var a, b StickTableEntry
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*StickTableEntry) MarshalBinary ¶ 

func (m *StickTableEntry) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*StickTableEntry) UnmarshalBinary ¶ 

func (m *StickTableEntry) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*StickTableEntry) Validate ¶ 

func (m *StickTableEntry) Validate(formats strfmt.Registry) error

Validate validates this stick table entry

type StickTableField ¶ 

type StickTableField struct {
	// field
	// Enum: [bytes_in_cnt bytes_in_rate bytes_out_cnt bytes_out_rate conn_cnt conn_cur conn_rate gpc0 gpc0_rate gpc1 gpc1_rate gpt0 http_req_cnt http_req_rate http_err_cnt http_err_rate server_id sess_cnt sess_rate]
	// +kubebuilder:validation:Enum=bytes_in_cnt;bytes_in_rate;bytes_out_cnt;bytes_out_rate;conn_cnt;conn_cur;conn_rate;gpc0;gpc0_rate;gpc1;gpc1_rate;gpt0;http_req_cnt;http_req_rate;http_err_cnt;http_err_rate;server_id;sess_cnt;sess_rate;
	Field string `json:"field,omitempty"`

	// period
	Period int64 `json:"period,omitempty"`

	// type
	// Enum: [rate counter]
	// +kubebuilder:validation:Enum=rate;counter;
	Type string `json:"type,omitempty"`
}

StickTableField stick table field

swagger:model StickTableField

func (*StickTableField) ContextValidate ¶ 

func (m *StickTableField) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this stick table field based on context it is used

func (StickTableField) Diff ¶ added in v5.1.0 

func (s StickTableField) Diff(t StickTableField, opts ...Options) map[string][]interface{}

Diff checks if two structs of type StickTableField are equal 

var a, b StickTableField
diff := a.Diff(b)

opts ...Options are ignored in this method

func (StickTableField) Equal ¶ added in v5.1.0 

func (s StickTableField) Equal(t StickTableField, opts ...Options) bool

Equal checks if two structs of type StickTableField are equal 

var a, b StickTableField
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*StickTableField) MarshalBinary ¶ 

func (m *StickTableField) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*StickTableField) UnmarshalBinary ¶ 

func (m *StickTableField) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*StickTableField) Validate ¶ 

func (m *StickTableField) Validate(formats strfmt.Registry) error

Validate validates this stick table field

type StickTables ¶ 

type StickTables []*StickTable

StickTables Stick Tables Array

Array of runtime stick tables ¶

swagger:model stick_tables

func (StickTables) ContextValidate ¶ 

func (m StickTables) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this stick tables based on the context it is used

func (StickTables) Diff ¶ added in v5.1.0 

func (s StickTables) Diff(t StickTables, opts ...Options) map[string][]interface{}

Diff checks if two structs of type StickTables are equal

By default empty maps and slices are equal to nil: 

var a, b StickTables
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b StickTables
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (StickTables) Equal ¶ added in v5.1.0 

func (s StickTables) Equal(t StickTables, opts ...Options) bool

Equal checks if two structs of type StickTables are equal

By default empty maps and slices are equal to nil: 

var a, b StickTables
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b StickTables
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (StickTables) Validate ¶ 

func (m StickTables) Validate(formats strfmt.Registry) error

Validate validates this stick tables

type TCPCheck ¶ 

type TCPCheck struct {
	// action
	// Required: true
	// Enum: [comment connect expect send send-lf send-binary send-binary-lf set-var set-var-fmt unset-var]
	// +kubebuilder:validation:Enum=comment;connect;expect;send;send-lf;send-binary;send-binary-lf;set-var;set-var-fmt;unset-var;
	Action string `json:"action"`

	// addr
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Addr string `json:"addr,omitempty"`

	// alpn
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Alpn string `json:"alpn,omitempty"`

	// check comment
	CheckComment string `json:"check_comment,omitempty"`

	// data
	Data string `json:"data,omitempty"`

	// default
	Default bool `json:"default,omitempty"`

	// error status
	// Enum: [L7OKC L7RSP L7STS L6RSP L4CON]
	// +kubebuilder:validation:Enum=L7OKC;L7RSP;L7STS;L6RSP;L4CON;
	ErrorStatus string `json:"error_status,omitempty"`

	// exclamation mark
	ExclamationMark bool `json:"exclamation_mark,omitempty"`

	// fmt
	Fmt string `json:"fmt,omitempty"`

	// hex fmt
	HexFmt string `json:"hex_fmt,omitempty"`

	// hex string
	HexString string `json:"hex_string,omitempty"`

	// index
	// Required: true
	// +kubebuilder:validation:Optional
	Index *int64 `json:"index"`

	// linger
	Linger bool `json:"linger,omitempty"`

	// log message
	LogMessage string `json:"log_message,omitempty"`

	// match
	// Pattern: ^[^\s]+$
	// Enum: [string rstring string-lf binary rbinary binary-lf]
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	// +kubebuilder:validation:Enum=string;rstring;string-lf;binary;rbinary;binary-lf;
	Match string `json:"match,omitempty"`

	// min recv
	MinRecv int64 `json:"min_recv,omitempty"`

	// ok status
	// Enum: [L7OK L7OKC L6OK L4OK]
	// +kubebuilder:validation:Enum=L7OK;L7OKC;L6OK;L4OK;
	OkStatus string `json:"ok_status,omitempty"`

	// on error
	OnError string `json:"on_error,omitempty"`

	// on success
	OnSuccess string `json:"on_success,omitempty"`

	// pattern
	Pattern string `json:"pattern,omitempty"`

	// port
	// Maximum: 65535
	// Minimum: 1
	// +kubebuilder:validation:Maximum=65535
	// +kubebuilder:validation:Minimum=1
	Port *int64 `json:"port,omitempty"`

	// port string
	PortString string `json:"port_string,omitempty"`

	// proto
	Proto string `json:"proto,omitempty"`

	// send proxy
	SendProxy bool `json:"send_proxy,omitempty"`

	// sni
	Sni string `json:"sni,omitempty"`

	// ssl
	Ssl bool `json:"ssl,omitempty"`

	// status code
	StatusCode string `json:"status-code,omitempty"`

	// tout status
	// Enum: [L7TOUT L6TOUT L4TOUT]
	// +kubebuilder:validation:Enum=L7TOUT;L6TOUT;L4TOUT;
	ToutStatus string `json:"tout_status,omitempty"`

	// var expr
	VarExpr string `json:"var_expr,omitempty"`

	// var fmt
	VarFmt string `json:"var_fmt,omitempty"`

	// var name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	VarName string `json:"var_name,omitempty"`

	// var scope
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	VarScope string `json:"var_scope,omitempty"`

	// via socks4
	ViaSocks4 bool `json:"via_socks4,omitempty"`
}

TCPCheck TCP Check

swagger:model tcp_check

func (*TCPCheck) ContextValidate ¶ 

func (m *TCPCheck) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this tcp check based on context it is used

func (TCPCheck) Diff ¶ added in v5.1.0 

func (s TCPCheck) Diff(t TCPCheck, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TCPCheck are equal

By default empty maps and slices are equal to nil: 

var a, b TCPCheck
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b TCPCheck
diff := a.Diff(b,Options{
	SkipIndex: true,
})

func (TCPCheck) Equal ¶ added in v5.1.0 

func (s TCPCheck) Equal(t TCPCheck, opts ...Options) bool

Equal checks if two structs of type TCPCheck are equal

By default empty maps and slices are equal to nil: 

var a, b TCPCheck
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b TCPCheck
equal := a.Equal(b,Options{
	SkipIndex: true,
})

func (*TCPCheck) MarshalBinary ¶ 

func (m *TCPCheck) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TCPCheck) UnmarshalBinary ¶ 

func (m *TCPCheck) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TCPCheck) Validate ¶ 

func (m *TCPCheck) Validate(formats strfmt.Registry) error

Validate validates this tcp check

type TCPChecks ¶ 

type TCPChecks []*TCPCheck

TCPChecks TCP Checks Array

swagger:model tcp_checks

func (TCPChecks) ContextValidate ¶ 

func (m TCPChecks) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this tcp checks based on the context it is used

func (TCPChecks) Diff ¶ added in v5.1.0 

func (s TCPChecks) Diff(t TCPChecks, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TCPChecks are equal

By default empty maps and slices are equal to nil: 

var a, b TCPChecks
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b TCPChecks
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (TCPChecks) Equal ¶ added in v5.1.0 

func (s TCPChecks) Equal(t TCPChecks, opts ...Options) bool

Equal checks if two structs of type TCPChecks are equal

By default empty maps and slices are equal to nil: 

var a, b TCPChecks
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b TCPChecks
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (TCPChecks) Validate ¶ 

func (m TCPChecks) Validate(formats strfmt.Registry) error

Validate validates this tcp checks

type TCPRequestRule ¶ 

type TCPRequestRule struct {
	// action
	// Enum: [accept attach-srv capture do-resolve expect-netscaler-cip expect-proxy lua reject sc-add-gpc sc-inc-gpc sc-inc-gpc0 sc-inc-gpc1 sc-set-gpt sc-set-gpt0 send-spoe-group set-bandwidth-limit set-dst-port set-dst set-log-level set-mark set-nice set-priority-class set-priority-offset set-src set-src-port set-tos set-var set-var-fmt silent-drop switch-mode track-sc0 track-sc1 track-sc2 track-sc unset-var use-service]
	// +kubebuilder:validation:Enum=accept;attach-srv;capture;do-resolve;expect-netscaler-cip;expect-proxy;lua;reject;sc-add-gpc;sc-inc-gpc;sc-inc-gpc0;sc-inc-gpc1;sc-set-gpt;sc-set-gpt0;send-spoe-group;set-bandwidth-limit;set-dst-port;set-dst;set-log-level;set-mark;set-nice;set-priority-class;set-priority-offset;set-src;set-src-port;set-tos;set-var;set-var-fmt;silent-drop;switch-mode;track-sc0;track-sc1;track-sc2;track-sc;unset-var;use-service;
	Action string `json:"action,omitempty"`

	// bandwidth limit limit
	BandwidthLimitLimit string `json:"bandwidth_limit_limit,omitempty"`

	// bandwidth limit name
	BandwidthLimitName string `json:"bandwidth_limit_name,omitempty"`

	// bandwidth limit period
	BandwidthLimitPeriod string `json:"bandwidth_limit_period,omitempty"`

	// capture len
	CaptureLen int64 `json:"capture_len,omitempty"`

	// capture sample
	// Pattern: ^(?:[A-Za-z]+\("([A-Za-z\s]+)"\)|[A-Za-z]+)
	// +kubebuilder:validation:Pattern=`^(?:[A-Za-z]+\("([A-Za-z\s]+)"\)|[A-Za-z]+)`
	CaptureSample string `json:"capture_sample,omitempty"`

	// cond
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond string `json:"cond,omitempty"`

	// cond test
	CondTest string `json:"cond_test,omitempty"`

	// expr
	Expr string `json:"expr,omitempty"`

	// gpt value
	GptValue string `json:"gpt_value,omitempty"`

	// index
	// Required: true
	// +kubebuilder:validation:Optional
	Index *int64 `json:"index"`

	// log level
	// Enum: [emerg alert crit err warning notice info debug silent]
	// +kubebuilder:validation:Enum=emerg;alert;crit;err;warning;notice;info;debug;silent;
	LogLevel string `json:"log_level,omitempty"`

	// lua action
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	LuaAction string `json:"lua_action,omitempty"`

	// lua params
	LuaParams string `json:"lua_params,omitempty"`

	// mark value
	// Pattern: ^(0x[0-9A-Fa-f]+|[0-9]+)$
	// +kubebuilder:validation:Pattern=`^(0x[0-9A-Fa-f]+|[0-9]+)$`
	MarkValue string `json:"mark_value,omitempty"`

	// nice value
	// Maximum: 1024
	// Minimum: -1024
	// +kubebuilder:validation:Maximum=1024
	// +kubebuilder:validation:Minimum=-1024
	NiceValue int64 `json:"nice_value,omitempty"`

	// resolve protocol
	// Enum: [ipv4 ipv6]
	// +kubebuilder:validation:Enum=ipv4;ipv6;
	ResolveProtocol string `json:"resolve_protocol,omitempty"`

	// resolve resolvers
	ResolveResolvers string `json:"resolve_resolvers,omitempty"`

	// resolve var
	ResolveVar string `json:"resolve_var,omitempty"`

	// rst ttl
	RstTTL int64 `json:"rst_ttl,omitempty"`

	// sc idx
	ScIdx string `json:"sc_idx,omitempty"`

	// sc inc id
	ScIncID string `json:"sc_inc_id,omitempty"`

	// sc int
	ScInt *int64 `json:"sc_int,omitempty"`

	// server name
	ServerName string `json:"server_name,omitempty"`

	// service name
	ServiceName string `json:"service_name,omitempty"`

	// spoe engine name
	SpoeEngineName string `json:"spoe_engine_name,omitempty"`

	// spoe group name
	SpoeGroupName string `json:"spoe_group_name,omitempty"`

	// switch mode proto
	SwitchModeProto string `json:"switch_mode_proto,omitempty"`

	// timeout
	Timeout *int64 `json:"timeout,omitempty"`

	// tos value
	// Pattern: ^(0x[0-9A-Fa-f]+|[0-9]+)$
	// +kubebuilder:validation:Pattern=`^(0x[0-9A-Fa-f]+|[0-9]+)$`
	TosValue string `json:"tos_value,omitempty"`

	// track key
	TrackKey string `json:"track_key,omitempty"`

	// track stick counter
	TrackStickCounter *int64 `json:"track_stick_counter,omitempty"`

	// track table
	TrackTable string `json:"track_table,omitempty"`

	// type
	// Required: true
	// Enum: [connection content inspect-delay session]
	// +kubebuilder:validation:Enum=connection;content;inspect-delay;session;
	Type string `json:"type"`

	// var format
	VarFormat string `json:"var_format,omitempty"`

	// var name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	VarName string `json:"var_name,omitempty"`

	// var scope
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	VarScope string `json:"var_scope,omitempty"`
}

TCPRequestRule TCP Request Rule

HAProxy TCP Request Rule configuration (corresponds to tcp-request) Example: {"cond":"if","cond_test":"{ src 192.168.0.0/16 }","index":0,"type":"connection"}

swagger:model tcp_request_rule

func (*TCPRequestRule) ContextValidate ¶ 

func (m *TCPRequestRule) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this tcp request rule based on context it is used

func (TCPRequestRule) Diff ¶ added in v5.1.0 

func (s TCPRequestRule) Diff(t TCPRequestRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TCPRequestRule are equal

By default empty maps and slices are equal to nil: 

var a, b TCPRequestRule
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b TCPRequestRule
diff := a.Diff(b,Options{
	SkipIndex: true,
})

func (TCPRequestRule) Equal ¶ added in v5.1.0 

func (s TCPRequestRule) Equal(t TCPRequestRule, opts ...Options) bool

Equal checks if two structs of type TCPRequestRule are equal

By default empty maps and slices are equal to nil: 

var a, b TCPRequestRule
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b TCPRequestRule
equal := a.Equal(b,Options{
	SkipIndex: true,
})

func (*TCPRequestRule) MarshalBinary ¶ 

func (m *TCPRequestRule) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TCPRequestRule) UnmarshalBinary ¶ 

func (m *TCPRequestRule) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TCPRequestRule) Validate ¶ 

func (m *TCPRequestRule) Validate(formats strfmt.Registry) error

Validate validates this tcp request rule

type TCPRequestRules ¶ 

type TCPRequestRules []*TCPRequestRule

TCPRequestRules TCP Request Rules Array

HAProxy TCP request rules array (corresponds to tcp-request directive)

swagger:model tcp_request_rules

func (TCPRequestRules) ContextValidate ¶ 

func (m TCPRequestRules) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this tcp request rules based on the context it is used

func (TCPRequestRules) Diff ¶ added in v5.1.0 

func (s TCPRequestRules) Diff(t TCPRequestRules, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TCPRequestRules are equal

By default empty maps and slices are equal to nil: 

var a, b TCPRequestRules
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b TCPRequestRules
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (TCPRequestRules) Equal ¶ added in v5.1.0 

func (s TCPRequestRules) Equal(t TCPRequestRules, opts ...Options) bool

Equal checks if two structs of type TCPRequestRules are equal

By default empty maps and slices are equal to nil: 

var a, b TCPRequestRules
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b TCPRequestRules
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (TCPRequestRules) Validate ¶ 

func (m TCPRequestRules) Validate(formats strfmt.Registry) error

Validate validates this tcp request rules

type TCPResponseRule ¶ 

type TCPResponseRule struct {
	// action
	// Enum: [accept close lua reject sc-add-gpc sc-inc-gpc sc-inc-gpc0 sc-inc-gpc1 sc-set-gpt sc-set-gpt0 send-spoe-group set-bandwidth-limit set-log-level set-mark set-nice set-tos set-var set-var-fmt silent-drop unset-var]
	// +kubebuilder:validation:Enum=accept;close;lua;reject;sc-add-gpc;sc-inc-gpc;sc-inc-gpc0;sc-inc-gpc1;sc-set-gpt;sc-set-gpt0;send-spoe-group;set-bandwidth-limit;set-log-level;set-mark;set-nice;set-tos;set-var;set-var-fmt;silent-drop;unset-var;
	Action string `json:"action,omitempty"`

	// bandwidth limit limit
	BandwidthLimitLimit string `json:"bandwidth_limit_limit,omitempty"`

	// bandwidth limit name
	BandwidthLimitName string `json:"bandwidth_limit_name,omitempty"`

	// bandwidth limit period
	BandwidthLimitPeriod string `json:"bandwidth_limit_period,omitempty"`

	// cond
	// Enum: [if unless]
	// +kubebuilder:validation:Enum=if;unless;
	Cond string `json:"cond,omitempty"`

	// cond test
	CondTest string `json:"cond_test,omitempty"`

	// expr
	Expr string `json:"expr,omitempty"`

	// index
	// Required: true
	// +kubebuilder:validation:Optional
	Index *int64 `json:"index"`

	// log level
	// Enum: [emerg alert crit err warning notice info debug silent]
	// +kubebuilder:validation:Enum=emerg;alert;crit;err;warning;notice;info;debug;silent;
	LogLevel string `json:"log_level,omitempty"`

	// lua action
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	LuaAction string `json:"lua_action,omitempty"`

	// lua params
	LuaParams string `json:"lua_params,omitempty"`

	// mark value
	// Pattern: ^(0x[0-9A-Fa-f]+|[0-9]+)$
	// +kubebuilder:validation:Pattern=`^(0x[0-9A-Fa-f]+|[0-9]+)$`
	MarkValue string `json:"mark_value,omitempty"`

	// nice value
	// Maximum: 1024
	// Minimum: -1024
	// +kubebuilder:validation:Maximum=1024
	// +kubebuilder:validation:Minimum=-1024
	NiceValue int64 `json:"nice_value,omitempty"`

	// rst ttl
	RstTTL int64 `json:"rst_ttl,omitempty"`

	// sc expr
	ScExpr string `json:"sc_expr,omitempty"`

	// sc id
	ScID int64 `json:"sc_id,omitempty"`

	// sc idx
	ScIdx int64 `json:"sc_idx,omitempty"`

	// sc int
	ScInt *int64 `json:"sc_int,omitempty"`

	// spoe engine
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	SpoeEngine string `json:"spoe_engine,omitempty"`

	// spoe group
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	SpoeGroup string `json:"spoe_group,omitempty"`

	// timeout
	Timeout *int64 `json:"timeout,omitempty"`

	// tos value
	// Pattern: ^(0x[0-9A-Fa-f]+|[0-9]+)$
	// +kubebuilder:validation:Pattern=`^(0x[0-9A-Fa-f]+|[0-9]+)$`
	TosValue string `json:"tos_value,omitempty"`

	// type
	// Required: true
	// Enum: [content inspect-delay]
	// +kubebuilder:validation:Enum=content;inspect-delay;
	Type string `json:"type"`

	// var format
	VarFormat string `json:"var_format,omitempty"`

	// var name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	VarName string `json:"var_name,omitempty"`

	// var scope
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	VarScope string `json:"var_scope,omitempty"`
}

TCPResponseRule TCP Response Rule

HAProxy TCP Response Rule configuration (corresponds to tcp-response) Example: {"cond":"if","cond_test":"{ src 192.168.0.0/16 }","index":0,"type":"content"}

swagger:model tcp_response_rule

func (*TCPResponseRule) ContextValidate ¶ 

func (m *TCPResponseRule) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this tcp response rule based on context it is used

func (TCPResponseRule) Diff ¶ added in v5.1.0 

func (s TCPResponseRule) Diff(t TCPResponseRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TCPResponseRule are equal

By default empty maps and slices are equal to nil: 

var a, b TCPResponseRule
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b TCPResponseRule
diff := a.Diff(b,Options{
	SkipIndex: true,
})

func (TCPResponseRule) Equal ¶ added in v5.1.0 

func (s TCPResponseRule) Equal(t TCPResponseRule, opts ...Options) bool

Equal checks if two structs of type TCPResponseRule are equal

By default empty maps and slices are equal to nil: 

var a, b TCPResponseRule
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b TCPResponseRule
equal := a.Equal(b,Options{
	SkipIndex: true,
})

func (*TCPResponseRule) MarshalBinary ¶ 

func (m *TCPResponseRule) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TCPResponseRule) UnmarshalBinary ¶ 

func (m *TCPResponseRule) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TCPResponseRule) Validate ¶ 

func (m *TCPResponseRule) Validate(formats strfmt.Registry) error

Validate validates this tcp response rule

type TCPResponseRules ¶ 

type TCPResponseRules []*TCPResponseRule

TCPResponseRules TCP Response Rules Array

HAProxy TCP response rules array (corresponds to tcp-response directive)

swagger:model tcp_response_rules

func (TCPResponseRules) ContextValidate ¶ 

func (m TCPResponseRules) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this tcp response rules based on the context it is used

func (TCPResponseRules) Diff ¶ added in v5.1.0 

func (s TCPResponseRules) Diff(t TCPResponseRules, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TCPResponseRules are equal

By default empty maps and slices are equal to nil: 

var a, b TCPResponseRules
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b TCPResponseRules
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (TCPResponseRules) Equal ¶ added in v5.1.0 

func (s TCPResponseRules) Equal(t TCPResponseRules, opts ...Options) bool

Equal checks if two structs of type TCPResponseRules are equal

By default empty maps and slices are equal to nil: 

var a, b TCPResponseRules
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b TCPResponseRules
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (TCPResponseRules) Validate ¶ 

func (m TCPResponseRules) Validate(formats strfmt.Registry) error

Validate validates this tcp response rules

type Table ¶ 

type Table struct {
	// expire
	// Pattern: ^\d+(ms|s|m|h|d)?$
	// +kubebuilder:validation:Pattern=`^\d+(ms|s|m|h|d)?$`
	Expire *string `json:"expire,omitempty"`

	// name
	Name string `json:"name,omitempty"`

	// no purge
	NoPurge bool `json:"no_purge,omitempty"`

	// size
	// Pattern: ^\d+(k|K|m|M|g|G)?$
	// +kubebuilder:validation:Pattern=`^\d+(k|K|m|M|g|G)?$`
	Size string `json:"size,omitempty"`

	// store
	Store string `json:"store,omitempty"`

	// type
	// Enum: [ip integer string binary]
	// +kubebuilder:validation:Enum=ip;integer;string;binary;
	Type string `json:"type,omitempty"`

	// type len
	TypeLen *int64 `json:"type_len,omitempty"`

	// write to
	WriteTo *string `json:"write_to,omitempty"`
}

Table table

swagger:model table

func (*Table) ContextValidate ¶ 

func (m *Table) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this table based on context it is used

func (Table) Diff ¶ added in v5.1.0 

func (s Table) Diff(t Table, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Table are equal 

var a, b Table
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Table) Equal ¶ added in v5.1.0 

func (s Table) Equal(t Table, opts ...Options) bool

Equal checks if two structs of type Table are equal 

var a, b Table
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Table) MarshalBinary ¶ 

func (m *Table) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Table) UnmarshalBinary ¶ 

func (m *Table) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Table) Validate ¶ 

func (m *Table) Validate(formats strfmt.Registry) error

Validate validates this table

type Tables ¶ 

type Tables []*Table

Tables Tables

HAProxy table array ¶

swagger:model tables

func (Tables) ContextValidate ¶ 

func (m Tables) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this tables based on the context it is used

func (Tables) Diff ¶ added in v5.1.0 

func (s Tables) Diff(t Tables, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Tables are equal

By default empty maps and slices are equal to nil: 

var a, b Tables
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Tables
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Tables) Equal ¶ added in v5.1.0 

func (s Tables) Equal(t Tables, opts ...Options) bool

Equal checks if two structs of type Tables are equal

By default empty maps and slices are equal to nil: 

var a, b Tables
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Tables
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Tables) Validate ¶ 

func (m Tables) Validate(formats strfmt.Registry) error

Validate validates this tables

type ThreadGroup ¶ 

type ThreadGroup struct {

	// group
	// Required: true
	Group *string `json:"group"`

	// num or range
	// Required: true
	NumOrRange *string `json:"num_or_range"`
}

ThreadGroup thread group

swagger:model ThreadGroup

func (*ThreadGroup) ContextValidate ¶ 

func (m *ThreadGroup) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this thread group based on context it is used

func (ThreadGroup) Diff ¶ added in v5.1.0 

func (s ThreadGroup) Diff(t ThreadGroup, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ThreadGroup are equal 

var a, b ThreadGroup
diff := a.Diff(b)

opts ...Options are ignored in this method

func (ThreadGroup) Equal ¶ added in v5.1.0 

func (s ThreadGroup) Equal(t ThreadGroup, opts ...Options) bool

Equal checks if two structs of type ThreadGroup are equal 

var a, b ThreadGroup
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*ThreadGroup) MarshalBinary ¶ 

func (m *ThreadGroup) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ThreadGroup) UnmarshalBinary ¶ 

func (m *ThreadGroup) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ThreadGroup) Validate ¶ 

func (m *ThreadGroup) Validate(formats strfmt.Registry) error

Validate validates this thread group

type Transaction ¶ 

type Transaction struct {

	// version
	Version int64 `json:"_version,omitempty"`

	// id
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	ID string `json:"id,omitempty"`

	// status
	// Enum: [failed outdated in_progress success]
	// +kubebuilder:validation:Enum=failed;outdated;in_progress;success;
	Status string `json:"status,omitempty"`
}

Transaction Configuration transaction

HAProxy configuration transaction Example: {"_version":2,"id":"273e3385-2d0c-4fb1-aa27-93cbb31ff203","status":"in_progress"}

swagger:model transaction

func (*Transaction) ContextValidate ¶ 

func (m *Transaction) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this transaction based on context it is used

func (Transaction) Diff ¶ added in v5.1.0 

func (s Transaction) Diff(t Transaction, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Transaction are equal 

var a, b Transaction
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Transaction) Equal ¶ added in v5.1.0 

func (s Transaction) Equal(t Transaction, opts ...Options) bool

Equal checks if two structs of type Transaction are equal 

var a, b Transaction
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Transaction) MarshalBinary ¶ 

func (m *Transaction) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Transaction) UnmarshalBinary ¶ 

func (m *Transaction) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Transaction) Validate ¶ 

func (m *Transaction) Validate(formats strfmt.Registry) error

Validate validates this transaction

type Transactions ¶ 

type Transactions []*Transaction

Transactions Transactions array

Configuration transactions array ¶

swagger:model transactions

func (Transactions) ContextValidate ¶ 

func (m Transactions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this transactions based on the context it is used

func (Transactions) Diff ¶ added in v5.1.0 

func (s Transactions) Diff(t Transactions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Transactions are equal

By default empty maps and slices are equal to nil: 

var a, b Transactions
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Transactions
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Transactions) Equal ¶ added in v5.1.0 

func (s Transactions) Equal(t Transactions, opts ...Options) bool

Equal checks if two structs of type Transactions are equal

By default empty maps and slices are equal to nil: 

var a, b Transactions
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Transactions
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Transactions) Validate ¶ 

func (m Transactions) Validate(formats strfmt.Registry) error

Validate validates this transactions

type User ¶ 

type User struct {

	// groups
	Groups string `json:"groups,omitempty"`

	// password
	// Required: true
	Password string `json:"password"`

	// secure password
	// Required: true
	SecurePassword *bool `json:"secure_password"`

	// username
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Username string `json:"username"`
}

User User

HAProxy userlist user ¶

swagger:model user

func (*User) ContextValidate ¶ 

func (m *User) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this user based on context it is used

func (User) Diff ¶ added in v5.1.0 

func (s User) Diff(t User, opts ...Options) map[string][]interface{}

Diff checks if two structs of type User are equal 

var a, b User
diff := a.Diff(b)

opts ...Options are ignored in this method

func (User) Equal ¶ added in v5.1.0 

func (s User) Equal(t User, opts ...Options) bool

Equal checks if two structs of type User are equal 

var a, b User
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*User) MarshalBinary ¶ 

func (m *User) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*User) UnmarshalBinary ¶ 

func (m *User) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*User) Validate ¶ 

func (m *User) Validate(formats strfmt.Registry) error

Validate validates this user

type Userlist ¶ 

type Userlist struct {
	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name string `json:"name"`
}

Userlist Userlist

HAProxy configuration of access control ¶

swagger:model userlist

func (*Userlist) ContextValidate ¶ 

func (m *Userlist) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this userlist based on context it is used

func (Userlist) Diff ¶ added in v5.1.0 

func (s Userlist) Diff(t Userlist, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Userlist are equal 

var a, b Userlist
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Userlist) Equal ¶ added in v5.1.0 

func (s Userlist) Equal(t Userlist, opts ...Options) bool

Equal checks if two structs of type Userlist are equal 

var a, b Userlist
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*Userlist) MarshalBinary ¶ 

func (m *Userlist) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Userlist) UnmarshalBinary ¶ 

func (m *Userlist) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Userlist) Validate ¶ 

func (m *Userlist) Validate(formats strfmt.Registry) error

Validate validates this userlist

type Userlists ¶ 

type Userlists []*Userlist

Userlists Userlists

HAProxy userlists array ¶

swagger:model userlists

func (Userlists) ContextValidate ¶ 

func (m Userlists) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this userlists based on the context it is used

func (Userlists) Diff ¶ added in v5.1.0 

func (s Userlists) Diff(t Userlists, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Userlists are equal

By default empty maps and slices are equal to nil: 

var a, b Userlists
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Userlists
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Userlists) Equal ¶ added in v5.1.0 

func (s Userlists) Equal(t Userlists, opts ...Options) bool

Equal checks if two structs of type Userlists are equal

By default empty maps and slices are equal to nil: 

var a, b Userlists
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Userlists
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Userlists) Validate ¶ 

func (m Userlists) Validate(formats strfmt.Registry) error

Validate validates this userlists

type Users ¶ 

type Users []*User

Users Users

HAProxy userlist users array ¶

swagger:model users

func (Users) ContextValidate ¶ 

func (m Users) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this users based on the context it is used

func (Users) Diff ¶ added in v5.1.0 

func (s Users) Diff(t Users, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Users are equal

By default empty maps and slices are equal to nil: 

var a, b Users
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Users
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Users) Equal ¶ added in v5.1.0 

func (s Users) Equal(t Users, opts ...Options) bool

Equal checks if two structs of type Users are equal

By default empty maps and slices are equal to nil: 

var a, b Users
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Users
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (Users) Validate ¶ 

func (m Users) Validate(formats strfmt.Registry) error

Validate validates this users

Source Files ¶

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.