models

package
v6.0.6 Latest Latest
Warning

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

 Go to latest Published: Oct 10, 2024 License: Apache-2.0 Imports: 9 Imported by: 0

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 (

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	// BackendBaseTransparentDisabled captures enum value "disabled"
	BackendBaseTransparentDisabled 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 (

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	// DefaultsBaseTransparentDisabled captures enum value "disabled"
	DefaultsBaseTransparentDisabled 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 (

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

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

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

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

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

	// FCGIAppBaseMpxsConnsDisabled captures enum value "disabled"
	FCGIAppBaseMpxsConnsDisabled 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 (

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	// GlobalBaseNumaCPUMappingDisabled captures enum value "disabled"
	GlobalBaseNumaCPUMappingDisabled string = "disabled"
)
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 (

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

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

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

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

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

	// GlobalLogSendHostnameEnabledDisabled captures enum value "disabled"
	GlobalLogSendHostnameEnabledDisabled 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 (

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

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

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

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

	// HTTPClientOptionsSslVerifyEmpty captures enum value ""
	HTTPClientOptionsSslVerifyEmpty string = ""

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

	// HTTPClientOptionsSslVerifyRequired captures enum value "required"
	HTTPClientOptionsSslVerifyRequired string = "required"
)
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"

	// HTTPRequestRuleTypeSetDashBcDashMark captures enum value "set-bc-mark"
	HTTPRequestRuleTypeSetDashBcDashMark string = "set-bc-mark"

	// HTTPRequestRuleTypeSetDashBcDashTos captures enum value "set-bc-tos"
	HTTPRequestRuleTypeSetDashBcDashTos string = "set-bc-tos"

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

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

	// HTTPRequestRuleTypeSetDashFcDashMark captures enum value "set-fc-mark"
	HTTPRequestRuleTypeSetDashFcDashMark string = "set-fc-mark"

	// HTTPRequestRuleTypeSetDashFcDashTos captures enum value "set-fc-tos"
	HTTPRequestRuleTypeSetDashFcDashTos string = "set-fc-tos"

	// 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"

	// 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"

	// HTTPResponseRuleTypeSetDashFcDashMark captures enum value "set-fc-mark"
	HTTPResponseRuleTypeSetDashFcDashMark string = "set-fc-mark"

	// HTTPResponseRuleTypeSetDashFcDashTos captures enum value "set-fc-tos"
	HTTPResponseRuleTypeSetDashFcDashTos string = "set-fc-tos"

	// 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"

	// 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 (

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

	// LuaPrependPathTypeCpath captures enum value "cpath"
	LuaPrependPathTypeCpath string = "cpath"
)
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 (

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

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

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

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

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

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

	// PerformanceOptionsProfilingTasksDisabled captures enum value "disabled"
	PerformanceOptionsProfilingTasksDisabled string = "disabled"
)
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 (

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

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

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

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

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

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

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

	// RingBaseFormatTimed captures enum value "timed"
	RingBaseFormatTimed 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 (

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

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

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

	// SslOptionsServerVerifyRequired captures enum value "required"
	SslOptionsServerVerifyRequired string = "required"
)
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"

	// TCPRequestRuleActionSetDashBcDashMark captures enum value "set-bc-mark"
	TCPRequestRuleActionSetDashBcDashMark string = "set-bc-mark"

	// TCPRequestRuleActionSetDashBcDashTos captures enum value "set-bc-tos"
	TCPRequestRuleActionSetDashBcDashTos string = "set-bc-tos"

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

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

	// TCPRequestRuleActionSetDashFcDashMark captures enum value "set-fc-mark"
	TCPRequestRuleActionSetDashFcDashMark string = "set-fc-mark"

	// TCPRequestRuleActionSetDashFcDashTos captures enum value "set-fc-tos"
	TCPRequestRuleActionSetDashFcDashTos string = "set-fc-tos"

	// 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"

	// 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"

	// TCPResponseRuleActionSetDashFcDashMark captures enum value "set-fc-mark"
	TCPResponseRuleActionSetDashFcDashMark string = "set-fc-mark"

	// TCPResponseRuleActionSetDashFcDashTos captures enum value "set-fc-tos"
	TCPResponseRuleActionSetDashFcDashTos string = "set-fc-tos"

	// 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 (

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	// FrontendBaseContstatsEnabled captures enum value "enabled"
	FrontendBaseContstatsEnabled 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 ¶ 

func CheckSameNilAndLen[T any](s, t []T, opts ...Options) bool

func CheckSameNilAndLenMap ¶ 

func CheckSameNilAndLenMap[S comparable, T any](s, t map[S]T, opts ...Options) bool

func Ptr ¶ 

func Ptr[V any](v V) *V

func ValueOrNil ¶ 

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"`

	// 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 ¶ 

func (s ACL) Diff(t ACL, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ACL are equal 

var a, b ACL
diff := a.Diff(b)

opts ...Options are ignored in this method

func (ACL) Equal ¶ 

func (s ACL) Equal(t ACL, opts ...Options) bool

Equal checks if two structs of type ACL are equal 

var a, b ACL
equal := a.Equal(b)

opts ...Options are ignored in this method

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 {
	BackendBase `json:",inline"`

	// Acl list
	ACLList Acls `json:"acl_list,omitempty"`

	// filter list
	FilterList Filters `json:"filter_list,omitempty"`

	// HTTP after response rule list
	HTTPAfterResponseRuleList HTTPAfterResponseRules `json:"http_after_response_rule_list,omitempty"`

	// HTTP check list
	HTTPCheckList HTTPChecks `json:"http_check_list,omitempty"`

	// HTTP error rule list
	HTTPErrorRuleList HTTPErrorRules `json:"http_error_rule_list,omitempty"`

	// HTTP request rule list
	HTTPRequestRuleList HTTPRequestRules `json:"http_request_rule_list,omitempty"`

	// HTTP response rule list
	HTTPResponseRuleList HTTPResponseRules `json:"http_response_rule_list,omitempty"`

	// log target list
	LogTargetList LogTargets `json:"log_target_list,omitempty"`

	// server switching rule list
	ServerSwitchingRuleList ServerSwitchingRules `json:"server_switching_rule_list,omitempty"`

	// stick rule list
	StickRuleList StickRules `json:"stick_rule_list,omitempty"`

	// TCP check rule list
	TCPCheckRuleList TCPChecks `json:"tcp_check_rule_list,omitempty"`

	// TCP request rule list
	TCPRequestRuleList TCPRequestRules `json:"tcp_request_rule_list,omitempty"`

	// TCP response rule list
	TCPResponseRuleList TCPResponseRules `json:"tcp_response_rule_list,omitempty"`

	// server templates
	ServerTemplates map[string]ServerTemplate `json:"server_templates,omitempty"`

	// servers
	Servers map[string]Server `json:"servers,omitempty"`
}

Backend Backend with all it's children resources

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 ¶ 

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 ¶ 

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) MarshalJSON ¶ 

func (m Backend) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*Backend) UnmarshalBinary ¶ 

func (m *Backend) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Backend) UnmarshalJSON ¶ 

func (m *Backend) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*Backend) Validate ¶ 

func (m *Backend) Validate(formats strfmt.Registry) error

Validate validates this backend

type BackendBase ¶ 

type BackendBase 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"`

	// 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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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"`

	// guid
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	GUID string `json:"guid,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 no delay
	// Enum: ["enabled","disabled"]
	// +kubebuilder:validation:Enum="enabled","disabled";
	HTTPNoDelay string `json:"http-no-delay,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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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"`

	// 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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	ServerFinTimeout *int64 `json:"server_fin_timeout,omitempty"`

	// server state file name
	ServerStateFileName string `json:"server_state_file_name,omitempty"`

	// server timeout
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	TunnelTimeout *int64 `json:"tunnel_timeout,omitempty"`

	// use fcgi app
	UseFCGIApp string `json:"use_fcgi_app,omitempty"`
}

BackendBase Backend Base

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_base

func (*BackendBase) ContextValidate ¶ 

func (m *BackendBase) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this backend base based on the context it is used

func (BackendBase) Diff ¶ 

func (s BackendBase) Diff(t BackendBase, opts ...Options) map[string][]interface{}

Diff checks if two structs of type BackendBase are equal

By default empty maps and slices are equal to nil: 

var a, b BackendBase
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b BackendBase
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (BackendBase) Equal ¶ 

func (s BackendBase) Equal(t BackendBase, opts ...Options) bool

Equal checks if two structs of type BackendBase are equal

By default empty maps and slices are equal to nil: 

var a, b BackendBase
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b BackendBase
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*BackendBase) MarshalBinary ¶ 

func (m *BackendBase) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*BackendBase) UnmarshalBinary ¶ 

func (m *BackendBase) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*BackendBase) Validate ¶ 

func (m *BackendBase) Validate(formats strfmt.Registry) error

Validate validates this backend base

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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"`

	// 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 ¶ 

func (s BackendSwitchingRule) Diff(t BackendSwitchingRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type BackendSwitchingRule are equal 

var a, b BackendSwitchingRule
diff := a.Diff(b)

opts ...Options are ignored in this method

func (BackendSwitchingRule) Equal ¶ 

func (s BackendSwitchingRule) Equal(t BackendSwitchingRule, opts ...Options) bool

Equal checks if two structs of type BackendSwitchingRule are equal 

var a, b BackendSwitchingRule
equal := a.Equal(b)

opts ...Options are ignored in this method

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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"`

	// default crt list
	DefaultCrtList []string `json:"default_crt_list,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"`

	// guid prefix
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	GUIDPrefix string `json:"guid_prefix,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"`

	// 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 ¶ 

func (s BindParams) Diff(t BindParams, opts ...Options) map[string][]interface{}

Diff checks if two structs of type BindParams are equal

By default empty maps and slices are equal to nil: 

var a, b BindParams
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b BindParams
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (BindParams) Equal ¶ 

func (s BindParams) Equal(t BindParams, opts ...Options) bool

Equal checks if two structs of type BindParams are equal

By default empty maps and slices are equal to nil: 

var a, b BindParams
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b BindParams
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 {

	// 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 ¶ 

func (s Capture) Diff(t Capture, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Capture are equal 

var a, b Capture
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Capture) Equal ¶ 

func (s Capture) Equal(t Capture, opts ...Options) bool

Equal checks if two structs of type Capture are equal 

var a, b Capture
equal := a.Equal(b)

opts ...Options are ignored in this method

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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 ¶ 

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 ¶ 

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"`

	// 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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 CrtLoad ¶ 

type CrtLoad struct {

	// Certificate alias
	Alias string `json:"alias,omitempty"`

	// Certificate filename
	// Required: true
	Certificate string `json:"certificate"`

	// OCSP issuer filename
	Issuer string `json:"issuer,omitempty"`

	// Private key filename
	Key string `json:"key,omitempty"`

	// OCSP response filename
	Ocsp string `json:"ocsp,omitempty"`

	// Automatic OCSP response update
	// Enum: ["enabled","disabled"]
	// +kubebuilder:validation:Enum="enabled","disabled";
	OcspUpdate string `json:"ocsp_update,omitempty"`

	// Signed Certificate Timestamp List filename
	Sctl string `json:"sctl,omitempty"`
}

CrtLoad Certificate load action

Loads a certificate from a store with options ¶

swagger:model crt_load

func (*CrtLoad) ContextValidate ¶ 

func (m *CrtLoad) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this crt load based on context it is used

func (CrtLoad) Diff ¶ 

func (s CrtLoad) Diff(t CrtLoad, opts ...Options) map[string][]interface{}

Diff checks if two structs of type CrtLoad are equal 

var a, b CrtLoad
diff := a.Diff(b)

opts ...Options are ignored in this method

func (CrtLoad) Equal ¶ 

func (s CrtLoad) Equal(t CrtLoad, opts ...Options) bool

Equal checks if two structs of type CrtLoad are equal 

var a, b CrtLoad
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*CrtLoad) MarshalBinary ¶ 

func (m *CrtLoad) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CrtLoad) UnmarshalBinary ¶ 

func (m *CrtLoad) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CrtLoad) Validate ¶ 

func (m *CrtLoad) Validate(formats strfmt.Registry) error

Validate validates this crt load

type CrtLoads ¶ 

type CrtLoads []*CrtLoad

CrtLoads List of certificates to load from a Certificate Store

swagger:model crt_loads

func (CrtLoads) ContextValidate ¶ 

func (m CrtLoads) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this crt loads based on the context it is used

func (CrtLoads) Diff ¶ 

func (s CrtLoads) Diff(t CrtLoads, opts ...Options) map[string][]interface{}

Diff checks if two structs of type CrtLoads are equal

By default empty maps and slices are equal to nil: 

var a, b CrtLoads
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b CrtLoads
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (CrtLoads) Equal ¶ 

func (s CrtLoads) Equal(t CrtLoads, opts ...Options) bool

Equal checks if two structs of type CrtLoads are equal

By default empty maps and slices are equal to nil: 

var a, b CrtLoads
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b CrtLoads
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (CrtLoads) Validate ¶ 

func (m CrtLoads) Validate(formats strfmt.Registry) error

Validate validates this crt loads

type CrtStore ¶ 

type CrtStore struct {

	// Default directory to fetch SSL certificates from
	CrtBase string `json:"crt_base,omitempty"`

	// Default directory to fetch SSL private keys from
	KeyBase string `json:"key_base,omitempty"`

	// loads
	Loads CrtLoads `json:"loads,omitempty"`

	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_]+$`
	Name string `json:"name"`
}

CrtStore Certificate Store

Storage mechanism to load and store certificates used in the configuration ¶

swagger:model crt_store

func (*CrtStore) ContextValidate ¶ 

func (m *CrtStore) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this crt store based on the context it is used

func (CrtStore) Diff ¶ 

func (s CrtStore) Diff(t CrtStore, opts ...Options) map[string][]interface{}

Diff checks if two structs of type CrtStore are equal

By default empty maps and slices are equal to nil: 

var a, b CrtStore
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b CrtStore
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (CrtStore) Equal ¶ 

func (s CrtStore) Equal(t CrtStore, opts ...Options) bool

Equal checks if two structs of type CrtStore are equal

By default empty maps and slices are equal to nil: 

var a, b CrtStore
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b CrtStore
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*CrtStore) MarshalBinary ¶ 

func (m *CrtStore) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CrtStore) UnmarshalBinary ¶ 

func (m *CrtStore) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CrtStore) Validate ¶ 

func (m *CrtStore) Validate(formats strfmt.Registry) error

Validate validates this crt store

type CrtStores ¶ 

type CrtStores []*CrtStore

CrtStores List of Certificate Stores

swagger:model crt_stores

func (CrtStores) ContextValidate ¶ 

func (m CrtStores) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this crt stores based on the context it is used

func (CrtStores) Diff ¶ 

func (s CrtStores) Diff(t CrtStores, opts ...Options) map[string][]interface{}

Diff checks if two structs of type CrtStores are equal

By default empty maps and slices are equal to nil: 

var a, b CrtStores
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b CrtStores
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (CrtStores) Equal ¶ 

func (s CrtStores) Equal(t CrtStores, opts ...Options) bool

Equal checks if two structs of type CrtStores are equal

By default empty maps and slices are equal to nil: 

var a, b CrtStores
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b CrtStores
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (CrtStores) Validate ¶ 

func (m CrtStores) Validate(formats strfmt.Registry) error

Validate validates this crt stores

type DebugOptions ¶ 

type DebugOptions struct {
	// anonkey
	// Maximum: 4.294967295e+09
	// Minimum: 0
	// +kubebuilder:validation:Maximum=4.294967295e+09
	// +kubebuilder:validation:Minimum=0
	Anonkey *int64 `json:"anonkey,omitempty"`

	// quiet
	Quiet bool `json:"quiet,omitempty"`

	// zero warning
	ZeroWarning bool `json:"zero_warning,omitempty"`
}

DebugOptions debug options

swagger:model debug_options

func (*DebugOptions) ContextValidate ¶ 

func (m *DebugOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this debug options based on context it is used

func (DebugOptions) Diff ¶ 

func (s DebugOptions) Diff(t DebugOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type DebugOptions are equal 

var a, b DebugOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (DebugOptions) Equal ¶ 

func (s DebugOptions) Equal(t DebugOptions, opts ...Options) bool

Equal checks if two structs of type DebugOptions are equal 

var a, b DebugOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*DebugOptions) MarshalBinary ¶ 

func (m *DebugOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DebugOptions) UnmarshalBinary ¶ 

func (m *DebugOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DebugOptions) Validate ¶ 

func (m *DebugOptions) Validate(formats strfmt.Registry) error

Validate validates this debug options

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 {
	DefaultsBase `json:",inline"`

	// HTTP check list
	HTTPCheckList HTTPChecks `json:"http_check_list,omitempty"`

	// HTTP error rule list
	HTTPErrorRuleList HTTPErrorRules `json:"http_error_rule_list,omitempty"`

	// log target list
	LogTargetList LogTargets `json:"log_target_list,omitempty"`

	// TCP check rule list
	TCPCheckRuleList TCPChecks `json:"tcp_check_rule_list,omitempty"`
}

Defaults Defaults with all it's children resources

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 ¶ 

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 ¶ 

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) MarshalJSON ¶ 

func (m Defaults) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*Defaults) UnmarshalBinary ¶ 

func (m *Defaults) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Defaults) UnmarshalJSON ¶ 

func (m *Defaults) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*Defaults) Validate ¶ 

func (m *Defaults) Validate(formats strfmt.Registry) error

Validate validates this defaults

type DefaultsBase ¶ 

type DefaultsBase 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"`

	// 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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	ClientFinTimeout *int64 `json:"client_fin_timeout,omitempty"`

	// client timeout
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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 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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	ServerFinTimeout *int64 `json:"server_fin_timeout,omitempty"`

	// server timeout
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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"`
}

DefaultsBase Defaults Base

HAProxy defaults configuration ¶

swagger:model defaults_base

func (*DefaultsBase) ContextValidate ¶ 

func (m *DefaultsBase) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this defaults base based on the context it is used

func (DefaultsBase) Diff ¶ 

func (s DefaultsBase) Diff(t DefaultsBase, opts ...Options) map[string][]interface{}

Diff checks if two structs of type DefaultsBase are equal

By default empty maps and slices are equal to nil: 

var a, b DefaultsBase
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b DefaultsBase
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (DefaultsBase) Equal ¶ 

func (s DefaultsBase) Equal(t DefaultsBase, opts ...Options) bool

Equal checks if two structs of type DefaultsBase are equal

By default empty maps and slices are equal to nil: 

var a, b DefaultsBase
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b DefaultsBase
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*DefaultsBase) MarshalBinary ¶ 

func (m *DefaultsBase) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DefaultsBase) UnmarshalBinary ¶ 

func (m *DefaultsBase) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DefaultsBase) Validate ¶ 

func (m *DefaultsBase) Validate(formats strfmt.Registry) error

Validate validates this defaults base

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 ¶ 

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 ¶ 

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 DeviceAtlasOptions ¶ 

type DeviceAtlasOptions 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"`
}

DeviceAtlasOptions device atlas options

swagger:model device_atlas_options

func (*DeviceAtlasOptions) ContextValidate ¶ 

func (m *DeviceAtlasOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this device atlas options based on context it is used

func (DeviceAtlasOptions) Diff ¶ 

func (s DeviceAtlasOptions) Diff(t DeviceAtlasOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type DeviceAtlasOptions are equal 

var a, b DeviceAtlasOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (DeviceAtlasOptions) Equal ¶ 

func (s DeviceAtlasOptions) Equal(t DeviceAtlasOptions, opts ...Options) bool

Equal checks if two structs of type DeviceAtlasOptions are equal 

var a, b DeviceAtlasOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*DeviceAtlasOptions) MarshalBinary ¶ 

func (m *DeviceAtlasOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceAtlasOptions) UnmarshalBinary ¶ 

func (m *DeviceAtlasOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceAtlasOptions) Validate ¶ 

func (m *DeviceAtlasOptions) Validate(formats strfmt.Registry) error

Validate validates this device atlas options

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 EnvironmentOptions ¶ 

type EnvironmentOptions struct {

	// preset envs
	PresetEnvs []*PresetEnv `json:"presetenv,omitempty"`

	// set envs
	SetEnvs []*SetEnv `json:"setenv,omitempty"`

	// resetenv
	Resetenv string `json:"resetenv,omitempty"`

	// unsetenv
	Unsetenv string `json:"unsetenv,omitempty"`
}

EnvironmentOptions environment options

swagger:model environment_options

func (*EnvironmentOptions) ContextValidate ¶ 

func (m *EnvironmentOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this environment options based on the context it is used

func (EnvironmentOptions) Diff ¶ 

func (s EnvironmentOptions) Diff(t EnvironmentOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type EnvironmentOptions are equal

By default empty maps and slices are equal to nil: 

var a, b EnvironmentOptions
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b EnvironmentOptions
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (EnvironmentOptions) Equal ¶ 

func (s EnvironmentOptions) Equal(t EnvironmentOptions, opts ...Options) bool

Equal checks if two structs of type EnvironmentOptions are equal

By default empty maps and slices are equal to nil: 

var a, b EnvironmentOptions
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b EnvironmentOptions
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*EnvironmentOptions) MarshalBinary ¶ 

func (m *EnvironmentOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*EnvironmentOptions) UnmarshalBinary ¶ 

func (m *EnvironmentOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*EnvironmentOptions) Validate ¶ 

func (m *EnvironmentOptions) Validate(formats strfmt.Registry) error

Validate validates this environment options

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 {
	FCGIAppBase `json:",inline"`

	// Acl list
	ACLList Acls `json:"acl_list,omitempty"`
}

FCGIApp App with all it's children resources

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 ¶ 

func (s FCGIApp) Diff(t FCGIApp, opts ...Options) map[string][]interface{}

Diff checks if two structs of type FCGIApp are equal

By default empty maps and slices are equal to nil: 

var a, b FCGIApp
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b FCGIApp
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (FCGIApp) Equal ¶ 

func (s FCGIApp) Equal(t FCGIApp, opts ...Options) bool

Equal checks if two structs of type FCGIApp are equal

By default empty maps and slices are equal to nil: 

var a, b FCGIApp
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b FCGIApp
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*FCGIApp) MarshalBinary ¶ 

func (m *FCGIApp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (FCGIApp) MarshalJSON ¶ 

func (m FCGIApp) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*FCGIApp) UnmarshalBinary ¶ 

func (m *FCGIApp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*FCGIApp) UnmarshalJSON ¶ 

func (m *FCGIApp) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*FCGIApp) Validate ¶ 

func (m *FCGIApp) Validate(formats strfmt.Registry) error

Validate validates this FCGI app

type FCGIAppBase ¶ 

type FCGIAppBase 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"`
}

FCGIAppBase FCGI application base

HAProxy FastCGI application configuration ¶

swagger:model fcgiAppBase

func (*FCGIAppBase) ContextValidate ¶ 

func (m *FCGIAppBase) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this fcgi app base based on the context it is used

func (FCGIAppBase) Diff ¶ 

func (s FCGIAppBase) Diff(t FCGIAppBase, opts ...Options) map[string][]interface{}
	SkipIndex: true,
})

func (FCGIAppBase) Equal ¶ 

func (s FCGIAppBase) Equal(t FCGIAppBase, opts ...Options) bool
	SkipIndex: true,
})

func (*FCGIAppBase) MarshalBinary ¶ 

func (m *FCGIAppBase) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*FCGIAppBase) UnmarshalBinary ¶ 

func (m *FCGIAppBase) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*FCGIAppBase) Validate ¶ 

func (m *FCGIAppBase) Validate(formats strfmt.Registry) error

Validate validates this fcgi app base

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 FiftyOneDegreesOptions ¶ 

type FiftyOneDegreesOptions 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"`
}

FiftyOneDegreesOptions fifty one degrees options

swagger:model fifty_one_degrees_options

func (*FiftyOneDegreesOptions) ContextValidate ¶ 

func (m *FiftyOneDegreesOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this fifty one degrees options based on context it is used

func (FiftyOneDegreesOptions) Diff ¶ 

func (s FiftyOneDegreesOptions) Diff(t FiftyOneDegreesOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type FiftyOneDegreesOptions are equal 

var a, b FiftyOneDegreesOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (FiftyOneDegreesOptions) Equal ¶ 

func (s FiftyOneDegreesOptions) Equal(t FiftyOneDegreesOptions, opts ...Options) bool

Equal checks if two structs of type FiftyOneDegreesOptions are equal 

var a, b FiftyOneDegreesOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*FiftyOneDegreesOptions) MarshalBinary ¶ 

func (m *FiftyOneDegreesOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*FiftyOneDegreesOptions) UnmarshalBinary ¶ 

func (m *FiftyOneDegreesOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*FiftyOneDegreesOptions) Validate ¶ 

func (m *FiftyOneDegreesOptions) Validate(formats strfmt.Registry) error

Validate validates this fifty one degrees options

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"`

	// 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: {"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 ¶ 

func (s Filter) Diff(t Filter, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Filter are equal 

var a, b Filter
diff := a.Diff(b)

opts ...Options are ignored in this method

func (Filter) Equal ¶ 

func (s Filter) Equal(t Filter, opts ...Options) bool

Equal checks if two structs of type Filter are equal 

var a, b Filter
equal := a.Equal(b)

opts ...Options are ignored in this method

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

func (m *ForcePersist) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ForcePersist) UnmarshalBinary ¶ 

func (m *ForcePersist) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ForcePersist) Validate ¶ 

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 ¶ 

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 ¶ 

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 {
	FrontendBase `json:",inline"`

	// Acl list
	ACLList Acls `json:"acl_list,omitempty"`

	// backend switching rule list
	BackendSwitchingRuleList BackendSwitchingRules `json:"backend_switching_rule_list,omitempty"`

	// capture list
	CaptureList Captures `json:"capture_list,omitempty"`

	// filter list
	FilterList Filters `json:"filter_list,omitempty"`

	// HTTP after response rule list
	HTTPAfterResponseRuleList HTTPAfterResponseRules `json:"http_after_response_rule_list,omitempty"`

	// HTTP error rule list
	HTTPErrorRuleList HTTPErrorRules `json:"http_error_rule_list,omitempty"`

	// HTTP request rule list
	HTTPRequestRuleList HTTPRequestRules `json:"http_request_rule_list,omitempty"`

	// HTTP response rule list
	HTTPResponseRuleList HTTPResponseRules `json:"http_response_rule_list,omitempty"`

	// log target list
	LogTargetList LogTargets `json:"log_target_list,omitempty"`

	// TCP request rule list
	TCPRequestRuleList TCPRequestRules `json:"tcp_request_rule_list,omitempty"`

	// binds
	Binds map[string]Bind `json:"binds,omitempty"`
}

Frontend Frontend with all it's children resources

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 ¶ 

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 ¶ 

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) MarshalJSON ¶ 

func (m Frontend) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*Frontend) UnmarshalBinary ¶ 

func (m *Frontend) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Frontend) UnmarshalJSON ¶ 

func (m *Frontend) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*Frontend) Validate ¶ 

func (m *Frontend) Validate(formats strfmt.Registry) error

Validate validates this frontend

type FrontendBase ¶ 

type FrontendBase 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"`

	// clflog
	Clflog bool `json:"clflog,omitempty"`

	// client fin timeout
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	ClientFinTimeout *int64 `json:"client_fin_timeout,omitempty"`

	// client timeout
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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"`

	// guid
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	GUID string `json:"guid,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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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"`
}

FrontendBase Frontend Base

HAProxy frontend configuration Example: {"default_backend":"test_backend","http_connection_mode":"http-keep-alive","maxconn":2000,"mode":"http","name":"test_frontend"}

swagger:model frontend_base

func (*FrontendBase) ContextValidate ¶ 

func (m *FrontendBase) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this frontend base based on the context it is used

func (FrontendBase) Diff ¶ 

func (s FrontendBase) Diff(t FrontendBase, opts ...Options) map[string][]interface{}

Diff checks if two structs of type FrontendBase are equal

By default empty maps and slices are equal to nil: 

var a, b FrontendBase
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b FrontendBase
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (FrontendBase) Equal ¶ 

func (s FrontendBase) Equal(t FrontendBase, opts ...Options) bool

Equal checks if two structs of type FrontendBase are equal

By default empty maps and slices are equal to nil: 

var a, b FrontendBase
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b FrontendBase
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*FrontendBase) MarshalBinary ¶ 

func (m *FrontendBase) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*FrontendBase) UnmarshalBinary ¶ 

func (m *FrontendBase) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*FrontendBase) Validate ¶ 

func (m *FrontendBase) Validate(formats strfmt.Registry) error

Validate validates this frontend base

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 {
	GlobalBase `json:",inline"`

	// log target list
	LogTargetList LogTargets `json:"log_target_list,omitempty"`
}

Global Frontend with all it's children resources

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 ¶ 

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 ¶ 

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) MarshalJSON ¶ 

func (m Global) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*Global) UnmarshalBinary ¶ 

func (m *Global) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Global) UnmarshalJSON ¶ 

func (m *Global) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*Global) Validate ¶ 

func (m *Global) Validate(formats strfmt.Registry) error

Validate validates this global

type GlobalBase ¶ 

type GlobalBase struct {

	// CPU maps
	CPUMaps []*CPUMap `json:"cpu_maps,omitempty"`

	// h1 case adjusts
	H1CaseAdjusts []*H1CaseAdjust `json:"h1_case_adjust,omitempty"`

	// runtime a p is
	RuntimeAPIs []*RuntimeAPI `json:"runtime_apis,omitempty"`

	// set var fmts
	SetVarFmts []*SetVarFmt `json:"set_var_fmt,omitempty"`

	// set vars
	SetVars []*SetVar `json:"set_var,omitempty"`

	// thread group lines
	ThreadGroupLines []*ThreadGroup `json:"thread_group_lines,omitempty"`

	// chroot
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Chroot string `json:"chroot,omitempty"`

	// close spread time
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	CloseSpreadTime *int64 `json:"close_spread_time,omitempty"`

	// cluster secret
	ClusterSecret string `json:"cluster_secret,omitempty"`

	// daemon
	Daemon bool `json:"daemon,omitempty"`

	// debug options
	DebugOptions *DebugOptions `json:"debug_options,omitempty"`

	// default path
	DefaultPath *GlobalDefaultPath `json:"default_path,omitempty"`

	// description
	Description string `json:"description,omitempty"`

	// device atlas options
	DeviceAtlasOptions *DeviceAtlasOptions `json:"device_atlas_options,omitempty"`

	// environment options
	EnvironmentOptions *EnvironmentOptions `json:"environment_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 *FiftyOneDegreesOptions `json:"fifty_one_degrees_options,omitempty"`

	// gid
	Gid int64 `json:"gid,omitempty"`

	// grace
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	HardStopAfter *int64 `json:"hard_stop_after,omitempty"`

	// harden
	Harden *GlobalHarden `json:"harden,omitempty"`

	// http client options
	HTTPClientOptions *HTTPClientOptions `json:"http_client_options,omitempty"`

	// http err codes
	HTTPErrCodes []*HTTPCodes `json:"http_err_codes,omitempty"`

	// http fail codes
	HTTPFailCodes []*HTTPCodes `json:"http_fail_codes,omitempty"`

	// insecure fork wanted
	InsecureForkWanted bool `json:"insecure_fork_wanted,omitempty"`

	// insecure setuid wanted
	InsecureSetuidWanted bool `json:"insecure_setuid_wanted,omitempty"`

	// limited quic
	LimitedQuic bool `json:"limited_quic,omitempty"`

	// localpeer
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Localpeer string `json:"localpeer,omitempty"`

	// log send hostname
	LogSendHostname *GlobalLogSendHostname `json:"log_send_hostname,omitempty"`

	// lua options
	LuaOptions *LuaOptions `json:"lua_options,omitempty"`

	// master worker
	MasterWorker bool `json:"master-worker,omitempty"`

	// mworker max reloads
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	MworkerMaxReloads *int64 `json:"mworker_max_reloads,omitempty"`

	// nbthread
	Nbthread int64 `json:"nbthread,omitempty"`

	// no quic
	NoQuic bool `json:"no_quic,omitempty"`

	// node
	Node string `json:"node,omitempty"`

	// numa cpu mapping
	// Enum: ["enabled","disabled"]
	// +kubebuilder:validation:Enum="enabled","disabled";
	NumaCPUMapping string `json:"numa_cpu_mapping,omitempty"`

	// ocsp update options
	OcspUpdateOptions *OcspUpdateOptions `json:"ocsp_update_options,omitempty"`

	// performance options
	PerformanceOptions *PerformanceOptions `json:"performance_options,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"`

	// set dumpable
	SetDumpable bool `json:"set_dumpable,omitempty"`

	// setcap
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	Setcap string `json:"setcap,omitempty"`

	// ssl options
	SslOptions *SslOptions `json:"ssl_options,omitempty"`

	// stats file
	StatsFile string `json:"stats_file,omitempty"`

	// stats maxconn
	StatsMaxconn *int64 `json:"stats_maxconn,omitempty"`

	// stats timeout
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	StatsTimeout *int64 `json:"stats_timeout,omitempty"`

	// strict limits
	StrictLimits bool `json:"strict_limits,omitempty"`

	// thread groups
	ThreadGroups int64 `json:"thread_groups,omitempty"`

	// tune buffer options
	TuneBufferOptions *TuneBufferOptions `json:"tune_buffer_options,omitempty"`

	// tune lua options
	TuneLuaOptions *TuneLuaOptions `json:"tune_lua_options,omitempty"`

	// tune options
	TuneOptions *TuneOptions `json:"tune_options,omitempty"`

	// tune quic options
	TuneQuicOptions *TuneQuicOptions `json:"tune_quic_options,omitempty"`

	// tune ssl options
	TuneSslOptions *TuneSslOptions `json:"tune_ssl_options,omitempty"`

	// tune vars options
	TuneVarsOptions *TuneVarsOptions `json:"tune_vars_options,omitempty"`

	// tune zlib options
	TuneZlibOptions *TuneZlibOptions `json:"tune_zlib_options,omitempty"`

	// uid
	UID int64 `json:"uid,omitempty"`

	// ulimit n
	Ulimitn int64 `json:"ulimit_n,omitempty"`

	// user
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	User string `json:"user,omitempty"`

	// wurfl options
	WurflOptions *WurflOptions `json:"wurfl_options,omitempty"`
}

GlobalBase Global Base

HAProxy global configuration ¶

swagger:model global_base

func (*GlobalBase) ContextValidate ¶ 

func (m *GlobalBase) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this global base based on the context it is used

func (GlobalBase) Diff ¶ 

func (s GlobalBase) Diff(t GlobalBase, opts ...Options) map[string][]interface{}

Diff checks if two structs of type GlobalBase are equal

By default empty maps and slices are equal to nil: 

var a, b GlobalBase
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b GlobalBase
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (GlobalBase) Equal ¶ 

func (s GlobalBase) Equal(t GlobalBase, opts ...Options) bool

Equal checks if two structs of type GlobalBase are equal

By default empty maps and slices are equal to nil: 

var a, b GlobalBase
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b GlobalBase
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*GlobalBase) MarshalBinary ¶ 

func (m *GlobalBase) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*GlobalBase) UnmarshalBinary ¶ 

func (m *GlobalBase) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*GlobalBase) Validate ¶ 

func (m *GlobalBase) Validate(formats strfmt.Registry) error

Validate validates this global base

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 ¶ 

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 ¶ 

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 GlobalHarden ¶ 

type GlobalHarden struct {

	// reject privileged ports
	RejectPrivilegedPorts *GlobalHardenRejectPrivilegedPorts `json:"reject_privileged_ports,omitempty"`
}

GlobalHarden global harden

swagger:model GlobalHarden

func (*GlobalHarden) ContextValidate ¶ 

func (m *GlobalHarden) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this global harden based on the context it is used

func (GlobalHarden) Diff ¶ 

func (s GlobalHarden) Diff(t GlobalHarden, opts ...Options) map[string][]interface{}

Diff checks if two structs of type GlobalHarden are equal

By default empty maps and slices are equal to nil: 

var a, b GlobalHarden
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b GlobalHarden
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (GlobalHarden) Equal ¶ 

func (s GlobalHarden) Equal(t GlobalHarden, opts ...Options) bool

Equal checks if two structs of type GlobalHarden are equal

By default empty maps and slices are equal to nil: 

var a, b GlobalHarden
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b GlobalHarden
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*GlobalHarden) MarshalBinary ¶ 

func (m *GlobalHarden) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*GlobalHarden) UnmarshalBinary ¶ 

func (m *GlobalHarden) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*GlobalHarden) Validate ¶ 

func (m *GlobalHarden) Validate(formats strfmt.Registry) error

Validate validates this global harden

type GlobalHardenRejectPrivilegedPorts ¶ 

type GlobalHardenRejectPrivilegedPorts struct {
	// quic
	// Enum: ["enabled","disabled"]
	// +kubebuilder:validation:Enum="enabled","disabled";
	Quic string `json:"quic,omitempty"`

	// tcp
	// Enum: ["enabled","disabled"]
	// +kubebuilder:validation:Enum="enabled","disabled";
	TCP string `json:"tcp,omitempty"`
}

GlobalHardenRejectPrivilegedPorts global harden reject privileged ports

swagger:model GlobalHardenRejectPrivilegedPorts

func (*GlobalHardenRejectPrivilegedPorts) ContextValidate ¶ 

func (m *GlobalHardenRejectPrivilegedPorts) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this global harden reject privileged ports based on context it is used

func (GlobalHardenRejectPrivilegedPorts) Diff ¶ 

func (s GlobalHardenRejectPrivilegedPorts) Diff(t GlobalHardenRejectPrivilegedPorts, opts ...Options) map[string][]interface{}

Diff checks if two structs of type GlobalHardenRejectPrivilegedPorts are equal 

var a, b GlobalHardenRejectPrivilegedPorts
diff := a.Diff(b)

opts ...Options are ignored in this method

func (GlobalHardenRejectPrivilegedPorts) Equal ¶ 

func (s GlobalHardenRejectPrivilegedPorts) Equal(t GlobalHardenRejectPrivilegedPorts, opts ...Options) bool

Equal checks if two structs of type GlobalHardenRejectPrivilegedPorts are equal 

var a, b GlobalHardenRejectPrivilegedPorts
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*GlobalHardenRejectPrivilegedPorts) MarshalBinary ¶ 

func (m *GlobalHardenRejectPrivilegedPorts) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*GlobalHardenRejectPrivilegedPorts) UnmarshalBinary ¶ 

func (m *GlobalHardenRejectPrivilegedPorts) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*GlobalHardenRejectPrivilegedPorts) Validate ¶ 

func (m *GlobalHardenRejectPrivilegedPorts) Validate(formats strfmt.Registry) error

Validate validates this global harden reject privileged ports

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 ¶ 

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 ¶ 

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 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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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"`

	// 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","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 ¶ 

func (s HTTPAfterResponseRule) Diff(t HTTPAfterResponseRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HTTPAfterResponseRule are equal 

var a, b HTTPAfterResponseRule
diff := a.Diff(b)

opts ...Options are ignored in this method

func (HTTPAfterResponseRule) Equal ¶ 

func (s HTTPAfterResponseRule) Equal(t HTTPAfterResponseRule, opts ...Options) bool

Equal checks if two structs of type HTTPAfterResponseRule are equal 

var a, b HTTPAfterResponseRule
equal := a.Equal(b)

opts ...Options are ignored in this method

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 ¶ 

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 ¶ 

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"`

	// 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 ¶ 

func (s HTTPCheck) Diff(t HTTPCheck, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HTTPCheck are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPCheck
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPCheck
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPCheck) Equal ¶ 

func (s HTTPCheck) Equal(t HTTPCheck, opts ...Options) bool

Equal checks if two structs of type HTTPCheck are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPCheck
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPCheck
equal := a.Equal(b,Options{
	NilSameAsEmpty: 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 ¶ 

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 ¶ 

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 HTTPClientOptions ¶ 

type HTTPClientOptions struct {
	// resolvers disabled
	// Enum: ["enabled","disabled"]
	// +kubebuilder:validation:Enum="enabled","disabled";
	ResolversDisabled string `json:"resolvers_disabled,omitempty"`

	// resolvers id
	ResolversID string `json:"resolvers_id,omitempty"`

	// resolvers prefer
	// Enum: ["ipv4","ipv6"]
	// +kubebuilder:validation:Enum="ipv4","ipv6";
	ResolversPrefer string `json:"resolvers_prefer,omitempty"`

	// retries
	Retries int64 `json:"retries,omitempty"`

	// ssl ca file
	SslCaFile string `json:"ssl_ca_file,omitempty"`

	// ssl verify
	// Enum: ["","none","required"]
	// +kubebuilder:validation:Enum="","none","required";
	SslVerify *string `json:"ssl_verify,omitempty"`

	// timeout connect
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	TimeoutConnect *int64 `json:"timeout_connect,omitempty"`
}

HTTPClientOptions http client options

swagger:model http_client_options

func (*HTTPClientOptions) ContextValidate ¶ 

func (m *HTTPClientOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this http client options based on context it is used

func (HTTPClientOptions) Diff ¶ 

func (s HTTPClientOptions) Diff(t HTTPClientOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HTTPClientOptions are equal 

var a, b HTTPClientOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (HTTPClientOptions) Equal ¶ 

func (s HTTPClientOptions) Equal(t HTTPClientOptions, opts ...Options) bool

Equal checks if two structs of type HTTPClientOptions are equal 

var a, b HTTPClientOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*HTTPClientOptions) MarshalBinary ¶ 

func (m *HTTPClientOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HTTPClientOptions) UnmarshalBinary ¶ 

func (m *HTTPClientOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HTTPClientOptions) Validate ¶ 

func (m *HTTPClientOptions) Validate(formats strfmt.Registry) error

Validate validates this http client options

type HTTPCodes ¶ 

type HTTPCodes struct {
	// value
	// Required: true
	// Pattern: ^[a-zA-Z0-9 +\-,]+$
	// +kubebuilder:validation:Pattern=`^[a-zA-Z0-9 +\-,]+$`
	Value *string `json:"value"`
}

HTTPCodes HTTP codes

swagger:model HTTPCodes

func (*HTTPCodes) ContextValidate ¶ 

func (m *HTTPCodes) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this HTTP codes based on context it is used

func (HTTPCodes) Diff ¶ 

func (s HTTPCodes) Diff(t HTTPCodes, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HTTPCodes are equal 

var a, b HTTPCodes
diff := a.Diff(b)

opts ...Options are ignored in this method

func (HTTPCodes) Equal ¶ 

func (s HTTPCodes) Equal(t HTTPCodes, opts ...Options) bool

Equal checks if two structs of type HTTPCodes are equal 

var a, b HTTPCodes
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*HTTPCodes) MarshalBinary ¶ 

func (m *HTTPCodes) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HTTPCodes) UnmarshalBinary ¶ 

func (m *HTTPCodes) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HTTPCodes) Validate ¶ 

func (m *HTTPCodes) Validate(formats strfmt.Registry) error

Validate validates this HTTP codes

type HTTPErrorRule ¶ 

type HTTPErrorRule struct {

	// return headers
	ReturnHeaders []*ReturnHeader `json:"return_hdrs,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"`

	// 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 ¶ 

func (s HTTPErrorRule) Diff(t HTTPErrorRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HTTPErrorRule are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPErrorRule
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPErrorRule
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPErrorRule) Equal ¶ 

func (s HTTPErrorRule) Equal(t HTTPErrorRule, opts ...Options) bool

Equal checks if two structs of type HTTPErrorRule are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPErrorRule
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPErrorRule
equal := a.Equal(b,Options{
	NilSameAsEmpty: 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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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"`

	// 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 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-bc-mark","set-bc-tos","set-dst","set-dst-port","set-fc-mark","set-fc-tos","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-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-bc-mark","set-bc-tos","set-dst","set-dst-port","set-fc-mark","set-fc-tos","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-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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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 ¶ 

func (s HTTPRequestRule) Diff(t HTTPRequestRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HTTPRequestRule are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPRequestRule
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPRequestRule
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPRequestRule) Equal ¶ 

func (s HTTPRequestRule) Equal(t HTTPRequestRule, opts ...Options) bool

Equal checks if two structs of type HTTPRequestRule are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPRequestRule
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPRequestRule
equal := a.Equal(b,Options{
	NilSameAsEmpty: 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 ¶ 

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 ¶ 

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"`

	// 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"`

	// 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 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-fc-mark","set-fc-tos","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-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-fc-mark","set-fc-tos","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-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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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 ¶ 

func (s HTTPResponseRule) Diff(t HTTPResponseRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type HTTPResponseRule are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPResponseRule
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPResponseRule
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (HTTPResponseRule) Equal ¶ 

func (s HTTPResponseRule) Equal(t HTTPResponseRule, opts ...Options) bool

Equal checks if two structs of type HTTPResponseRule are equal

By default empty maps and slices are equal to nil: 

var a, b HTTPResponseRule
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b HTTPResponseRule
equal := a.Equal(b,Options{
	NilSameAsEmpty: 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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

func (m *IgnorePersist) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IgnorePersist) UnmarshalBinary ¶ 

func (m *IgnorePersist) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IgnorePersist) Validate ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 {
	LogForwardBase `json:",inline"`

	// log target list
	LogTargetList LogTargets `json:"log_target_list,omitempty"`

	// binds
	Binds map[string]Bind `json:"binds,omitempty"`

	// dgram binds
	DgramBinds map[string]DgramBind `json:"dgram_binds,omitempty"`
}

LogForward LogForward with all it's children resources

swagger:model LogForward

func (*LogForward) ContextValidate ¶ 

func (m *LogForward) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this log forward based on the context it is used

func (LogForward) Diff ¶ 

func (s LogForward) Diff(t LogForward, opts ...Options) map[string][]interface{}

Diff checks if two structs of type LogForward are equal

By default empty maps and slices are equal to nil: 

var a, b LogForward
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b LogForward
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (LogForward) Equal ¶ 

func (s LogForward) Equal(t LogForward, opts ...Options) bool

Equal checks if two structs of type LogForward are equal

By default empty maps and slices are equal to nil: 

var a, b LogForward
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b LogForward
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*LogForward) MarshalBinary ¶ 

func (m *LogForward) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (LogForward) MarshalJSON ¶ 

func (m LogForward) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*LogForward) UnmarshalBinary ¶ 

func (m *LogForward) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*LogForward) UnmarshalJSON ¶ 

func (m *LogForward) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*LogForward) Validate ¶ 

func (m *LogForward) Validate(formats strfmt.Registry) error

Validate validates this log forward

type LogForwardBase ¶ 

type LogForwardBase 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
	// Maximum: 2.147483647e+09
	// Minimum: 0
	// +kubebuilder:validation:Maximum=2.147483647e+09
	// +kubebuilder:validation:Minimum=0
	TimeoutClient *int64 `json:"timeout_client,omitempty"`
}

LogForwardBase Log Forward

HAProxy log forward configuration ¶

swagger:model log_forward_base

func (*LogForwardBase) ContextValidate ¶ 

func (m *LogForwardBase) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this log forward base based on context it is used

func (LogForwardBase) Diff ¶ 

func (s LogForwardBase) Diff(t LogForwardBase, opts ...Options) map[string][]interface{}

Diff checks if two structs of type LogForwardBase are equal 

var a, b LogForwardBase
diff := a.Diff(b)

opts ...Options are ignored in this method

func (LogForwardBase) Equal ¶ 

func (s LogForwardBase) Equal(t LogForwardBase, opts ...Options) bool

Equal checks if two structs of type LogForwardBase are equal 

var a, b LogForwardBase
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*LogForwardBase) MarshalBinary ¶ 

func (m *LogForwardBase) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*LogForwardBase) UnmarshalBinary ¶ 

func (m *LogForwardBase) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*LogForwardBase) Validate ¶ 

func (m *LogForwardBase) Validate(formats strfmt.Registry) error

Validate validates this log forward base

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 ¶ 

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 ¶ 

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"`

	// 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 ¶ 

func (s LogTarget) Diff(t LogTarget, opts ...Options) map[string][]interface{}

Diff checks if two structs of type LogTarget are equal 

var a, b LogTarget
diff := a.Diff(b)

opts ...Options are ignored in this method

func (LogTarget) Equal ¶ 

func (s LogTarget) Equal(t LogTarget, opts ...Options) bool

Equal checks if two structs of type LogTarget are equal 

var a, b LogTarget
equal := a.Equal(b)

opts ...Options are ignored in this method

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 LuaOptions ¶ 

type LuaOptions struct {

	// load per thread
	LoadPerThread string `json:"load_per_thread,omitempty"`

	// loads
	Loads []*LuaLoad `json:"loads,omitempty"`

	// prepend path
	PrependPath []*LuaPrependPath `json:"prepend_path,omitempty"`
}

LuaOptions lua options

swagger:model lua_options

func (*LuaOptions) ContextValidate ¶ 

func (m *LuaOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this lua options based on the context it is used

func (LuaOptions) Diff ¶ 

func (s LuaOptions) Diff(t LuaOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type LuaOptions are equal

By default empty maps and slices are equal to nil: 

var a, b LuaOptions
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b LuaOptions
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (LuaOptions) Equal ¶ 

func (s LuaOptions) Equal(t LuaOptions, opts ...Options) bool

Equal checks if two structs of type LuaOptions are equal

By default empty maps and slices are equal to nil: 

var a, b LuaOptions
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b LuaOptions
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*LuaOptions) MarshalBinary ¶ 

func (m *LuaOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*LuaOptions) UnmarshalBinary ¶ 

func (m *LuaOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*LuaOptions) Validate ¶ 

func (m *LuaOptions) Validate(formats strfmt.Registry) error

Validate validates this lua options

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 {
	MailersSectionBase `json:",inline"`

	// mailer entries
	MailerEntries map[string]MailerEntry `json:"mailer_entries,omitempty"`
}

MailersSection MailersSection with all it's children resources

swagger:model MailersSection

func (*MailersSection) ContextValidate ¶ 

func (m *MailersSection) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this mailers section based on the context it is used

func (MailersSection) Diff ¶ 

func (s MailersSection) Diff(t MailersSection, opts ...Options) map[string][]interface{}

Diff checks if two structs of type MailersSection are equal

By default empty maps and slices are equal to nil: 

var a, b MailersSection
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b MailersSection
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (MailersSection) Equal ¶ 

func (s MailersSection) Equal(t MailersSection, opts ...Options) bool

Equal checks if two structs of type MailersSection are equal

By default empty maps and slices are equal to nil: 

var a, b MailersSection
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b MailersSection
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*MailersSection) MarshalBinary ¶ 

func (m *MailersSection) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (MailersSection) MarshalJSON ¶ 

func (m MailersSection) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*MailersSection) UnmarshalBinary ¶ 

func (m *MailersSection) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*MailersSection) UnmarshalJSON ¶ 

func (m *MailersSection) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*MailersSection) Validate ¶ 

func (m *MailersSection) Validate(formats strfmt.Registry) error

Validate validates this mailers section

type MailersSectionBase ¶ 

type MailersSectionBase 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"`
}

MailersSectionBase Mailers Section Base

A list of SMTP servers used by HAProxy to send emails.

swagger:model mailers_section_base

func (*MailersSectionBase) ContextValidate ¶ 

func (m *MailersSectionBase) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this mailers section base based on context it is used

func (MailersSectionBase) Diff ¶ 

func (s MailersSectionBase) Diff(t MailersSectionBase, opts ...Options) map[string][]interface{}

Diff checks if two structs of type MailersSectionBase are equal 

var a, b MailersSectionBase
diff := a.Diff(b)

opts ...Options are ignored in this method

func (MailersSectionBase) Equal ¶ 

func (s MailersSectionBase) Equal(t MailersSectionBase, opts ...Options) bool

Equal checks if two structs of type MailersSectionBase are equal 

var a, b MailersSectionBase
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*MailersSectionBase) MarshalBinary ¶ 

func (m *MailersSectionBase) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*MailersSectionBase) UnmarshalBinary ¶ 

func (m *MailersSectionBase) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*MailersSectionBase) Validate ¶ 

func (m *MailersSectionBase) Validate(formats strfmt.Registry) error

Validate validates this mailers section base

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 struct {

	// error
	Error string `json:"error,omitempty"`

	// runtime API
	RuntimeAPI string `json:"runtimeAPI,omitempty"`

	// stats
	Stats []*NativeStat `json:"stats,omitempty"`
}

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 ¶ 

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 ¶ 

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) MarshalBinary ¶ 

func (m *NativeStats) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NativeStats) UnmarshalBinary ¶ 

func (m *NativeStats) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NativeStats) Validate ¶ 

func (m *NativeStats) Validate(formats strfmt.Registry) error

Validate validates this native stats

type OcspUpdateOptions ¶ 

type OcspUpdateOptions struct {

	// disable
	Disable *bool `json:"disable,omitempty"`

	// httpproxy
	Httpproxy *OcspUpdateOptionsHttpproxy `json:"httpproxy,omitempty"`

	// Sets the maximum interval between two automatic updates of the same OCSP response.This time is expressed in seconds
	Maxdelay *int64 `json:"maxdelay,omitempty"`

	// Sets the minimum interval between two automatic updates of the same OCSP response. This time is expressed in seconds
	Mindelay *int64 `json:"mindelay,omitempty"`

	// mode
	// Enum: ["enabled","disabled"]
	// +kubebuilder:validation:Enum="enabled","disabled";
	Mode string `json:"mode,omitempty"`
}

OcspUpdateOptions ocsp update options

swagger:model ocsp_update_options

func (*OcspUpdateOptions) ContextValidate ¶ 

func (m *OcspUpdateOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this ocsp update options based on the context it is used

func (OcspUpdateOptions) Diff ¶ 

func (s OcspUpdateOptions) Diff(t OcspUpdateOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type OcspUpdateOptions are equal

By default empty maps and slices are equal to nil: 

var a, b OcspUpdateOptions
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b OcspUpdateOptions
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (OcspUpdateOptions) Equal ¶ 

func (s OcspUpdateOptions) Equal(t OcspUpdateOptions, opts ...Options) bool

Equal checks if two structs of type OcspUpdateOptions are equal

By default empty maps and slices are equal to nil: 

var a, b OcspUpdateOptions
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b OcspUpdateOptions
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*OcspUpdateOptions) MarshalBinary ¶ 

func (m *OcspUpdateOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*OcspUpdateOptions) UnmarshalBinary ¶ 

func (m *OcspUpdateOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*OcspUpdateOptions) Validate ¶ 

func (m *OcspUpdateOptions) Validate(formats strfmt.Registry) error

Validate validates this ocsp update options

type OcspUpdateOptionsHttpproxy ¶ 

type OcspUpdateOptionsHttpproxy struct {
	// 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"`
}

OcspUpdateOptionsHttpproxy ocsp update options httpproxy

swagger:model OcspUpdateOptionsHttpproxy

func (*OcspUpdateOptionsHttpproxy) ContextValidate ¶ 

func (m *OcspUpdateOptionsHttpproxy) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this ocsp update options httpproxy based on context it is used

func (OcspUpdateOptionsHttpproxy) Diff ¶ 

func (s OcspUpdateOptionsHttpproxy) Diff(t OcspUpdateOptionsHttpproxy, opts ...Options) map[string][]interface{}

Diff checks if two structs of type OcspUpdateOptionsHttpproxy are equal 

var a, b OcspUpdateOptionsHttpproxy
diff := a.Diff(b)

opts ...Options are ignored in this method

func (OcspUpdateOptionsHttpproxy) Equal ¶ 

func (s OcspUpdateOptionsHttpproxy) Equal(t OcspUpdateOptionsHttpproxy, opts ...Options) bool

Equal checks if two structs of type OcspUpdateOptionsHttpproxy are equal 

var a, b OcspUpdateOptionsHttpproxy
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*OcspUpdateOptionsHttpproxy) MarshalBinary ¶ 

func (m *OcspUpdateOptionsHttpproxy) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*OcspUpdateOptionsHttpproxy) UnmarshalBinary ¶ 

func (m *OcspUpdateOptionsHttpproxy) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*OcspUpdateOptionsHttpproxy) Validate ¶ 

func (m *OcspUpdateOptionsHttpproxy) Validate(formats strfmt.Registry) error

Validate validates this ocsp update options httpproxy

type Options ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 {
	PeerSectionBase `json:",inline"`

	// log target list
	LogTargetList LogTargets `json:"log_target_list,omitempty"`

	// binds
	Binds map[string]Bind `json:"binds,omitempty"`

	// peer entries
	PeerEntries map[string]PeerEntry `json:"peer_entries,omitempty"`

	// servers
	Servers map[string]Server `json:"servers,omitempty"`
}

PeerSection Peer Section with all it's children resources

swagger:model PeerSection

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 ¶ 

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 ¶ 

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) MarshalJSON ¶ 

func (m PeerSection) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*PeerSection) UnmarshalBinary ¶ 

func (m *PeerSection) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PeerSection) UnmarshalJSON ¶ 

func (m *PeerSection) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*PeerSection) Validate ¶ 

func (m *PeerSection) Validate(formats strfmt.Registry) error

Validate validates this peer section

type PeerSectionBase ¶ 

type PeerSectionBase 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"`
}

PeerSectionBase Peer Section Base

HAProxy peer_section configuration

swagger:model peer_section_base

func (*PeerSectionBase) ContextValidate ¶ 

func (m *PeerSectionBase) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this peer section base based on the context it is used

func (PeerSectionBase) Diff ¶ 

func (s PeerSectionBase) Diff(t PeerSectionBase, opts ...Options) map[string][]interface{}

Diff checks if two structs of type PeerSectionBase are equal

By default empty maps and slices are equal to nil: 

var a, b PeerSectionBase
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b PeerSectionBase
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (PeerSectionBase) Equal ¶ 

func (s PeerSectionBase) Equal(t PeerSectionBase, opts ...Options) bool

Equal checks if two structs of type PeerSectionBase are equal

By default empty maps and slices are equal to nil: 

var a, b PeerSectionBase
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b PeerSectionBase
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*PeerSectionBase) MarshalBinary ¶ 

func (m *PeerSectionBase) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PeerSectionBase) UnmarshalBinary ¶ 

func (m *PeerSectionBase) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PeerSectionBase) Validate ¶ 

func (m *PeerSectionBase) Validate(formats strfmt.Registry) error

Validate validates this peer section base

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 ¶ 

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 ¶ 

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 PerformanceOptions ¶ 

type PerformanceOptions struct {

	// busy polling
	BusyPolling bool `json:"busy_polling,omitempty"`

	// max spread checks
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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"`

	// maxzlibmem
	Maxzlibmem int64 `json:"maxzlibmem,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"`

	// profiling memory
	// Enum: ["enabled","disabled"]
	// +kubebuilder:validation:Enum="enabled","disabled";
	ProfilingMemory string `json:"profiling_memory,omitempty"`

	// profiling tasks
	// Enum: ["auto","enabled","disabled"]
	// +kubebuilder:validation:Enum="auto","enabled","disabled";
	ProfilingTasks string `json:"profiling_tasks,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"`

	// spread checks
	SpreadChecks int64 `json:"spread_checks,omitempty"`

	// thread hard limit
	ThreadHardLimit *int64 `json:"thread_hard_limit,omitempty"`
}

PerformanceOptions performance options

swagger:model performance_options

func (*PerformanceOptions) ContextValidate ¶ 

func (m *PerformanceOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this performance options based on context it is used

func (PerformanceOptions) Diff ¶ 

func (s PerformanceOptions) Diff(t PerformanceOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type PerformanceOptions are equal 

var a, b PerformanceOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (PerformanceOptions) Equal ¶ 

func (s PerformanceOptions) Equal(t PerformanceOptions, opts ...Options) bool

Equal checks if two structs of type PerformanceOptions are equal 

var a, b PerformanceOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*PerformanceOptions) MarshalBinary ¶ 

func (m *PerformanceOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PerformanceOptions) UnmarshalBinary ¶ 

func (m *PerformanceOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PerformanceOptions) Validate ¶ 

func (m *PerformanceOptions) Validate(formats strfmt.Registry) error

Validate validates this performance options

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 HAProxy Information

General HAProxy process information ¶

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 {
	ResolverBase `json:",inline"`

	// nameservers
	Nameservers map[string]Nameserver `json:"nameservers,omitempty"`
}

Resolver Resolver with all it's children resources

swagger:model Resolver

func (*Resolver) ContextValidate ¶ 

func (m *Resolver) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this resolver based on the context it is used

func (Resolver) Diff ¶ 

func (s Resolver) Diff(t Resolver, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Resolver are equal

By default empty maps and slices are equal to nil: 

var a, b Resolver
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Resolver
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Resolver) Equal ¶ 

func (s Resolver) Equal(t Resolver, opts ...Options) bool

Equal checks if two structs of type Resolver are equal

By default empty maps and slices are equal to nil: 

var a, b Resolver
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Resolver
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Resolver) MarshalBinary ¶ 

func (m *Resolver) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Resolver) MarshalJSON ¶ 

func (m Resolver) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*Resolver) UnmarshalBinary ¶ 

func (m *Resolver) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Resolver) UnmarshalJSON ¶ 

func (m *Resolver) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*Resolver) Validate ¶ 

func (m *Resolver) Validate(formats strfmt.Registry) error

Validate validates this resolver

type ResolverBase ¶ 

type ResolverBase 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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	HoldNx *int64 `json:"hold_nx,omitempty"`

	// hold obsolete
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	HoldObsolete *int64 `json:"hold_obsolete,omitempty"`

	// hold other
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	HoldOther *int64 `json:"hold_other,omitempty"`

	// hold refused
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	HoldRefused *int64 `json:"hold_refused,omitempty"`

	// hold timeout
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	HoldTimeout *int64 `json:"hold_timeout,omitempty"`

	// hold valid
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	TimeoutResolve int64 `json:"timeout_resolve,omitempty"`

	// timeout retry
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	TimeoutRetry int64 `json:"timeout_retry,omitempty"`
}

ResolverBase Resolver Base

Runtime DNS configuration ¶

swagger:model resolver_base

func (*ResolverBase) ContextValidate ¶ 

func (m *ResolverBase) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this resolver base based on context it is used

func (ResolverBase) Diff ¶ 

func (s ResolverBase) Diff(t ResolverBase, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ResolverBase are equal 

var a, b ResolverBase
diff := a.Diff(b)

opts ...Options are ignored in this method

func (ResolverBase) Equal ¶ 

func (s ResolverBase) Equal(t ResolverBase, opts ...Options) bool

Equal checks if two structs of type ResolverBase are equal 

var a, b ResolverBase
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*ResolverBase) MarshalBinary ¶ 

func (m *ResolverBase) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ResolverBase) UnmarshalBinary ¶ 

func (m *ResolverBase) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ResolverBase) Validate ¶ 

func (m *ResolverBase) Validate(formats strfmt.Registry) error

Validate validates this resolver base

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 {
	RingBase `json:",inline"`

	// servers
	Servers map[string]Server `json:"servers,omitempty"`
}

Ring Ring with all it's children resources

swagger:model Ring

func (*Ring) ContextValidate ¶ 

func (m *Ring) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this ring based on the context it is used

func (Ring) Diff ¶ 

func (s Ring) Diff(t Ring, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Ring are equal

By default empty maps and slices are equal to nil: 

var a, b Ring
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Ring
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Ring) Equal ¶ 

func (s Ring) Equal(t Ring, opts ...Options) bool

Equal checks if two structs of type Ring are equal

By default empty maps and slices are equal to nil: 

var a, b Ring
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Ring
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Ring) MarshalBinary ¶ 

func (m *Ring) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Ring) MarshalJSON ¶ 

func (m Ring) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*Ring) UnmarshalBinary ¶ 

func (m *Ring) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Ring) UnmarshalJSON ¶ 

func (m *Ring) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*Ring) Validate ¶ 

func (m *Ring) Validate(formats strfmt.Registry) error

Validate validates this ring

type RingBase ¶ 

type RingBase 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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	Size *int64 `json:"size,omitempty"`

	// timeout connect
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	TimeoutConnect *int64 `json:"timeout_connect,omitempty"`

	// timeout server
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	TimeoutServer *int64 `json:"timeout_server,omitempty"`
}

RingBase Ring Base

HAProxy ring configuration ¶

swagger:model ring_base

func (*RingBase) ContextValidate ¶ 

func (m *RingBase) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this ring base based on context it is used

func (RingBase) Diff ¶ 

func (s RingBase) Diff(t RingBase, opts ...Options) map[string][]interface{}

Diff checks if two structs of type RingBase are equal 

var a, b RingBase
diff := a.Diff(b)

opts ...Options are ignored in this method

func (RingBase) Equal ¶ 

func (s RingBase) Equal(t RingBase, opts ...Options) bool

Equal checks if two structs of type RingBase are equal 

var a, b RingBase
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*RingBase) MarshalBinary ¶ 

func (m *RingBase) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RingBase) UnmarshalBinary ¶ 

func (m *RingBase) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RingBase) Validate ¶ 

func (m *RingBase) Validate(formats strfmt.Registry) error

Validate validates this ring base

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	Downinter *int64 `json:"downinter,omitempty"`

	// error limit
	ErrorLimit *int64 `json:"error_limit,omitempty"`

	// fall
	Fall *int64 `json:"fall,omitempty"`

	// fastinter
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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"`

	// metadata
	Metadata map[string]interface{} `json:"metadata,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 ¶ 

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 ¶ 

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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	Downinter *int64 `json:"downinter,omitempty"`

	// error limit
	ErrorLimit int64 `json:"error_limit,omitempty"`

	// fall
	Fall *int64 `json:"fall,omitempty"`

	// fastinter
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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"`

	// guid
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	GUID string `json:"guid,omitempty"`

	// hash key
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	HashKey string `json:"hash_key,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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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 conn name
	// Pattern: ^[^\s]+$
	// +kubebuilder:validation:Pattern=`^[^\s]+$`
	PoolConnName string `json:"pool_conn_name,omitempty"`

	// pool low conn
	PoolLowConn *int64 `json:"pool_low_conn,omitempty"`

	// pool max conn
	PoolMaxConn *int64 `json:"pool_max_conn,omitempty"`

	// pool purge delay
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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 ¶ 

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 ¶ 

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) 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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

func (m *ServerParamsSetProxyV2TlvFmt) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ServerParamsSetProxyV2TlvFmt) UnmarshalBinary ¶ 

func (m *ServerParamsSetProxyV2TlvFmt) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ServerParamsSetProxyV2TlvFmt) Validate ¶ 

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"`

	// 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 }","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 ¶ 

func (s ServerSwitchingRule) Diff(t ServerSwitchingRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type ServerSwitchingRule are equal 

var a, b ServerSwitchingRule
diff := a.Diff(b)

opts ...Options are ignored in this method

func (ServerSwitchingRule) Equal ¶ 

func (s ServerSwitchingRule) Equal(t ServerSwitchingRule, opts ...Options) bool

Equal checks if two structs of type ServerSwitchingRule are equal 

var a, b ServerSwitchingRule
equal := a.Equal(b)

opts ...Options are ignored in this method

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 {

	// algorithm
	Algorithm string `json:"algorithm,omitempty"`

	// authority key id
	AuthorityKeyID string `json:"authority_key_id,omitempty"`

	// 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"`

	// serial
	Serial string `json:"serial,omitempty"`

	// sha1 finger print
	Sha1FingerPrint string `json:"sha1_finger_print,omitempty"`

	// sha256 finger print
	Sha256FingerPrint string `json:"sha256_finger_print,omitempty"`

	// File size in bytes.
	// Read Only: true
	Size *int64 `json:"size,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"`

	// subject key id
	SubjectKeyID string `json:"subject_key_id,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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 SslOptions ¶ 

type SslOptions struct {

	// ssl engines
	SslEngines []*SslEngine `json:"engines,omitempty"`

	// ca base
	CaBase string `json:"ca_base,omitempty"`

	// crt base
	CrtBase string `json:"crt_base,omitempty"`

	// default bind ciphers
	DefaultBindCiphers string `json:"default_bind_ciphers,omitempty"`

	// default bind ciphersuites
	DefaultBindCiphersuites string `json:"default_bind_ciphersuites,omitempty"`

	// default bind client sigalgs
	DefaultBindClientSigalgs string `json:"default_bind_client_sigalgs,omitempty"`

	// default bind curves
	DefaultBindCurves string `json:"default_bind_curves,omitempty"`

	// default bind options
	DefaultBindOptions string `json:"default_bind_options,omitempty"`

	// default bind sigalgs
	DefaultBindSigalgs string `json:"default_bind_sigalgs,omitempty"`

	// default server ciphers
	DefaultServerCiphers string `json:"default_server_ciphers,omitempty"`

	// default server ciphersuites
	DefaultServerCiphersuites string `json:"default_server_ciphersuites,omitempty"`

	// default server client sigalgs
	DefaultServerClientSigalgs string `json:"default_server_client_sigalgs,omitempty"`

	// default server curves
	DefaultServerCurves string `json:"default_server_curves,omitempty"`

	// default server options
	DefaultServerOptions string `json:"default_server_options,omitempty"`

	// default server sigalgs
	DefaultServerSigalgs string `json:"default_server_sigalgs,omitempty"`

	// dh param file
	DhParamFile string `json:"dh_param_file,omitempty"`

	// issuers chain path
	IssuersChainPath string `json:"issuers_chain_path,omitempty"`

	// load extra files
	LoadExtraFiles string `json:"load_extra_files,omitempty"`

	// maxsslconn
	Maxsslconn int64 `json:"maxsslconn,omitempty"`

	// maxsslrate
	Maxsslrate int64 `json:"maxsslrate,omitempty"`

	// mode async
	// Enum: ["enabled","disabled"]
	// +kubebuilder:validation:Enum="enabled","disabled";
	ModeAsync string `json:"mode_async,omitempty"`

	// propquery
	Propquery string `json:"propquery,omitempty"`

	// provider
	Provider string `json:"provider,omitempty"`

	// provider path
	ProviderPath string `json:"provider_path,omitempty"`

	// security level
	// Maximum: 5
	// Minimum: 0
	// +kubebuilder:validation:Maximum=5
	// +kubebuilder:validation:Minimum=0
	SecurityLevel *int64 `json:"security_level,omitempty"`

	// server verify
	// Enum: ["none","required"]
	// +kubebuilder:validation:Enum="none","required";
	ServerVerify string `json:"server_verify,omitempty"`

	// skip self issued ca
	SkipSelfIssuedCa bool `json:"skip_self_issued_ca,omitempty"`
}

SslOptions ssl options

swagger:model ssl_options

func (*SslOptions) ContextValidate ¶ 

func (m *SslOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this ssl options based on the context it is used

func (SslOptions) Diff ¶ 

func (s SslOptions) Diff(t SslOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type SslOptions are equal

By default empty maps and slices are equal to nil: 

var a, b SslOptions
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SslOptions
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (SslOptions) Equal ¶ 

func (s SslOptions) Equal(t SslOptions, opts ...Options) bool

Equal checks if two structs of type SslOptions are equal

By default empty maps and slices are equal to nil: 

var a, b SslOptions
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b SslOptions
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*SslOptions) MarshalBinary ¶ 

func (m *SslOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SslOptions) UnmarshalBinary ¶ 

func (m *SslOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SslOptions) Validate ¶ 

func (m *SslOptions) Validate(formats strfmt.Registry) error

Validate validates this ssl options

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	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 ¶ 

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 ¶ 

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"`

	// 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: {"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 ¶ 

func (s StickRule) Diff(t StickRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type StickRule are equal 

var a, b StickRule
diff := a.Diff(b)

opts ...Options are ignored in this method

func (StickRule) Equal ¶ 

func (s StickRule) Equal(t StickRule, opts ...Options) bool

Equal checks if two structs of type StickRule are equal 

var a, b StickRule
equal := a.Equal(b)

opts ...Options are ignored in this method

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 ¶ 

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 ¶ 

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"`

	// 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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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"`

	// linger
	Linger bool `json:"linger,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 ¶ 

func (s TCPCheck) Diff(t TCPCheck, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TCPCheck are equal 

var a, b TCPCheck
diff := a.Diff(b)

opts ...Options are ignored in this method

func (TCPCheck) Equal ¶ 

func (s TCPCheck) Equal(t TCPCheck, opts ...Options) bool

Equal checks if two structs of type TCPCheck are equal 

var a, b TCPCheck
equal := a.Equal(b)

opts ...Options are ignored in this method

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 ¶ 

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 ¶ 

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-bc-mark","set-bc-tos","set-dst-port","set-dst","set-fc-mark","set-fc-tos","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-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-bc-mark","set-bc-tos","set-dst-port","set-dst","set-fc-mark","set-fc-tos","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-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"`

	// 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 ¶ 

func (s TCPRequestRule) Diff(t TCPRequestRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TCPRequestRule are equal 

var a, b TCPRequestRule
diff := a.Diff(b)

opts ...Options are ignored in this method

func (TCPRequestRule) Equal ¶ 

func (s TCPRequestRule) Equal(t TCPRequestRule, opts ...Options) bool

Equal checks if two structs of type TCPRequestRule are equal 

var a, b TCPRequestRule
equal := a.Equal(b)

opts ...Options are ignored in this method

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 ¶ 

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 ¶ 

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-fc-mark","set-fc-tos","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-fc-mark","set-fc-tos","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"`

	// 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 ¶ 

func (s TCPResponseRule) Diff(t TCPResponseRule, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TCPResponseRule are equal 

var a, b TCPResponseRule
diff := a.Diff(b)

opts ...Options are ignored in this method

func (TCPResponseRule) Equal ¶ 

func (s TCPResponseRule) Equal(t TCPResponseRule, opts ...Options) bool

Equal checks if two structs of type TCPResponseRule are equal 

var a, b TCPResponseRule
equal := a.Equal(b)

opts ...Options are ignored in this method

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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 TuneBufferOptions ¶ 

type TuneBufferOptions 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"`

	// pipesize
	Pipesize int64 `json:"pipesize,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"`

	// 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"`
}

TuneBufferOptions tune buffer options

swagger:model tune_buffer_options

func (*TuneBufferOptions) ContextValidate ¶ 

func (m *TuneBufferOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this tune buffer options based on context it is used

func (TuneBufferOptions) Diff ¶ 

func (s TuneBufferOptions) Diff(t TuneBufferOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TuneBufferOptions are equal 

var a, b TuneBufferOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (TuneBufferOptions) Equal ¶ 

func (s TuneBufferOptions) Equal(t TuneBufferOptions, opts ...Options) bool

Equal checks if two structs of type TuneBufferOptions are equal 

var a, b TuneBufferOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*TuneBufferOptions) MarshalBinary ¶ 

func (m *TuneBufferOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TuneBufferOptions) UnmarshalBinary ¶ 

func (m *TuneBufferOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TuneBufferOptions) Validate ¶ 

func (m *TuneBufferOptions) Validate(formats strfmt.Registry) error

Validate validates this tune buffer options

type TuneLuaOptions ¶ 

type TuneLuaOptions struct {
	// burst timeout
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	BurstTimeout *int64 `json:"burst_timeout,omitempty"`

	// forced yield
	ForcedYield int64 `json:"forced_yield,omitempty"`

	// log loggers
	// Enum: ["enabled","disabled"]
	// +kubebuilder:validation:Enum="enabled","disabled";
	LogLoggers string `json:"log_loggers,omitempty"`

	// log stderr
	// Enum: ["auto","enabled","disabled"]
	// +kubebuilder:validation:Enum="auto","enabled","disabled";
	LogStderr string `json:"log_stderr,omitempty"`

	// maxmem
	Maxmem *int64 `json:"maxmem,omitempty"`

	// service timeout
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	ServiceTimeout *int64 `json:"service_timeout,omitempty"`

	// session timeout
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	SessionTimeout *int64 `json:"session_timeout,omitempty"`

	// task timeout
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	TaskTimeout *int64 `json:"task_timeout,omitempty"`
}

TuneLuaOptions tune lua options

swagger:model tune_lua_options

func (*TuneLuaOptions) ContextValidate ¶ 

func (m *TuneLuaOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this tune lua options based on context it is used

func (TuneLuaOptions) Diff ¶ 

func (s TuneLuaOptions) Diff(t TuneLuaOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TuneLuaOptions are equal 

var a, b TuneLuaOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (TuneLuaOptions) Equal ¶ 

func (s TuneLuaOptions) Equal(t TuneLuaOptions, opts ...Options) bool

Equal checks if two structs of type TuneLuaOptions are equal 

var a, b TuneLuaOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*TuneLuaOptions) MarshalBinary ¶ 

func (m *TuneLuaOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TuneLuaOptions) UnmarshalBinary ¶ 

func (m *TuneLuaOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TuneLuaOptions) Validate ¶ 

func (m *TuneLuaOptions) Validate(formats strfmt.Registry) error

Validate validates this tune lua options

type TuneOptions ¶ 

type TuneOptions struct {
	// applet zero copy forwarding
	// Enum: ["enabled","disabled"]
	// +kubebuilder:validation:Enum="enabled","disabled";
	AppletZeroCopyForwarding string `json:"applet_zero_copy_forwarding,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 glitches threshold
	H2BeGlitchesThreshold *int64 `json:"h2_be_glitches_threshold,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 glitches threshold
	H2FeGlitchesThreshold *int64 `json:"h2_fe_glitches_threshold,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 fe max total streams
	H2FeMaxTotalStreams *int64 `json:"h2_fe_max_total_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"`

	// 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"`

	// 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"`

	// ring queues
	RingQueues *int64 `json:"ring_queues,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"`

	// stick counters
	StickCounters *int64 `json:"stick_counters,omitempty"`
}

TuneOptions tune options

swagger:model tune_options

func (*TuneOptions) ContextValidate ¶ 

func (m *TuneOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this tune options based on context it is used

func (TuneOptions) Diff ¶ 

func (s TuneOptions) Diff(t TuneOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TuneOptions are equal 

var a, b TuneOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (TuneOptions) Equal ¶ 

func (s TuneOptions) Equal(t TuneOptions, opts ...Options) bool

Equal checks if two structs of type TuneOptions are equal 

var a, b TuneOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*TuneOptions) MarshalBinary ¶ 

func (m *TuneOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TuneOptions) UnmarshalBinary ¶ 

func (m *TuneOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TuneOptions) Validate ¶ 

func (m *TuneOptions) Validate(formats strfmt.Registry) error

Validate validates this tune options

type TuneQuicOptions ¶ 

type TuneQuicOptions struct {

	// frontend conn tx buffers limit
	FrontendConnTxBuffersLimit *int64 `json:"frontend_conn_tx_buffers_limit,omitempty"`

	// frontend max idle timeout
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	FrontendMaxIdleTimeout *int64 `json:"frontend_max_idle_timeout,omitempty"`

	// frontend max streams bidi
	FrontendMaxStreamsBidi *int64 `json:"frontend_max_streams_bidi,omitempty"`

	// max frame loss
	MaxFrameLoss *int64 `json:"max_frame_loss,omitempty"`

	// reorder ratio
	// Maximum: 100
	// Minimum: 0
	// +kubebuilder:validation:Maximum=100
	// +kubebuilder:validation:Minimum=0
	ReorderRatio *int64 `json:"reorder_ratio,omitempty"`

	// retry threshold
	RetryThreshold *int64 `json:"retry_threshold,omitempty"`

	// socket owner
	// Enum: ["listener","connection"]
	// +kubebuilder:validation:Enum="listener","connection";
	SocketOwner string `json:"socket_owner,omitempty"`

	// zero copy fwd send
	// Enum: ["enabled","disabled"]
	// +kubebuilder:validation:Enum="enabled","disabled";
	ZeroCopyFwdSend string `json:"zero_copy_fwd_send,omitempty"`
}

TuneQuicOptions tune quic options

swagger:model tune_quic_options

func (*TuneQuicOptions) ContextValidate ¶ 

func (m *TuneQuicOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this tune quic options based on context it is used

func (TuneQuicOptions) Diff ¶ 

func (s TuneQuicOptions) Diff(t TuneQuicOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TuneQuicOptions are equal 

var a, b TuneQuicOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (TuneQuicOptions) Equal ¶ 

func (s TuneQuicOptions) Equal(t TuneQuicOptions, opts ...Options) bool

Equal checks if two structs of type TuneQuicOptions are equal 

var a, b TuneQuicOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*TuneQuicOptions) MarshalBinary ¶ 

func (m *TuneQuicOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TuneQuicOptions) UnmarshalBinary ¶ 

func (m *TuneQuicOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TuneQuicOptions) Validate ¶ 

func (m *TuneQuicOptions) Validate(formats strfmt.Registry) error

Validate validates this tune quic options

type TuneSslOptions ¶ 

type TuneSslOptions struct {

	// cachesize
	Cachesize *int64 `json:"cachesize,omitempty"`

	// capture buffer size
	CaptureBufferSize *int64 `json:"capture_buffer_size,omitempty"`

	// ctx cache size
	CtxCacheSize int64 `json:"ctx_cache_size,omitempty"`

	// default dh param
	DefaultDhParam int64 `json:"default_dh_param,omitempty"`

	// force private cache
	ForcePrivateCache bool `json:"force_private_cache,omitempty"`

	// keylog
	// Enum: ["enabled","disabled"]
	// +kubebuilder:validation:Enum="enabled","disabled";
	Keylog string `json:"keylog,omitempty"`

	// lifetime
	// Minimum: 0
	// +kubebuilder:validation:Minimum=0
	Lifetime *int64 `json:"lifetime,omitempty"`

	// maxrecord
	Maxrecord *int64 `json:"maxrecord,omitempty"`

	// ocsp update max delay
	OcspUpdateMaxDelay *int64 `json:"ocsp_update_max_delay,omitempty"`

	// ocsp update min delay
	OcspUpdateMinDelay *int64 `json:"ocsp_update_min_delay,omitempty"`
}

TuneSslOptions tune ssl options

swagger:model tune_ssl_options

func (*TuneSslOptions) ContextValidate ¶ 

func (m *TuneSslOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this tune ssl options based on context it is used

func (TuneSslOptions) Diff ¶ 

func (s TuneSslOptions) Diff(t TuneSslOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TuneSslOptions are equal 

var a, b TuneSslOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (TuneSslOptions) Equal ¶ 

func (s TuneSslOptions) Equal(t TuneSslOptions, opts ...Options) bool

Equal checks if two structs of type TuneSslOptions are equal 

var a, b TuneSslOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*TuneSslOptions) MarshalBinary ¶ 

func (m *TuneSslOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TuneSslOptions) UnmarshalBinary ¶ 

func (m *TuneSslOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TuneSslOptions) Validate ¶ 

func (m *TuneSslOptions) Validate(formats strfmt.Registry) error

Validate validates this tune ssl options

type TuneVarsOptions ¶ 

type TuneVarsOptions struct {

	// global max size
	GlobalMaxSize *int64 `json:"global_max_size,omitempty"`

	// proc max size
	ProcMaxSize *int64 `json:"proc_max_size,omitempty"`

	// reqres max size
	ReqresMaxSize *int64 `json:"reqres_max_size,omitempty"`

	// sess max size
	SessMaxSize *int64 `json:"sess_max_size,omitempty"`

	// txn max size
	TxnMaxSize *int64 `json:"txn_max_size,omitempty"`
}

TuneVarsOptions tune vars options

swagger:model tune_vars_options

func (*TuneVarsOptions) ContextValidate ¶ 

func (m *TuneVarsOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this tune vars options based on context it is used

func (TuneVarsOptions) Diff ¶ 

func (s TuneVarsOptions) Diff(t TuneVarsOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TuneVarsOptions are equal 

var a, b TuneVarsOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (TuneVarsOptions) Equal ¶ 

func (s TuneVarsOptions) Equal(t TuneVarsOptions, opts ...Options) bool

Equal checks if two structs of type TuneVarsOptions are equal 

var a, b TuneVarsOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*TuneVarsOptions) MarshalBinary ¶ 

func (m *TuneVarsOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TuneVarsOptions) UnmarshalBinary ¶ 

func (m *TuneVarsOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TuneVarsOptions) Validate ¶ 

func (m *TuneVarsOptions) Validate(formats strfmt.Registry) error

Validate validates this tune vars options

type TuneZlibOptions ¶ 

type TuneZlibOptions struct {
	// memlevel
	// Maximum: 9
	// Minimum: 1
	// +kubebuilder:validation:Maximum=9
	// +kubebuilder:validation:Minimum=1
	Memlevel int64 `json:"memlevel,omitempty"`

	// windowsize
	// Maximum: 15
	// Minimum: 8
	// +kubebuilder:validation:Maximum=15
	// +kubebuilder:validation:Minimum=8
	Windowsize int64 `json:"windowsize,omitempty"`
}

TuneZlibOptions tune zlib options

swagger:model tune_zlib_options

func (*TuneZlibOptions) ContextValidate ¶ 

func (m *TuneZlibOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this tune zlib options based on context it is used

func (TuneZlibOptions) Diff ¶ 

func (s TuneZlibOptions) Diff(t TuneZlibOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type TuneZlibOptions are equal 

var a, b TuneZlibOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (TuneZlibOptions) Equal ¶ 

func (s TuneZlibOptions) Equal(t TuneZlibOptions, opts ...Options) bool

Equal checks if two structs of type TuneZlibOptions are equal 

var a, b TuneZlibOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*TuneZlibOptions) MarshalBinary ¶ 

func (m *TuneZlibOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TuneZlibOptions) UnmarshalBinary ¶ 

func (m *TuneZlibOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TuneZlibOptions) Validate ¶ 

func (m *TuneZlibOptions) Validate(formats strfmt.Registry) error

Validate validates this tune zlib options

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 ¶ 

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 ¶ 

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 {
	UserlistBase `json:",inline"`

	// groups
	Groups map[string]Group `json:"groups,omitempty"`

	// users
	Users map[string]User `json:"users,omitempty"`
}

Userlist Userlist with all it's children resources

swagger:model Userlist

func (*Userlist) ContextValidate ¶ 

func (m *Userlist) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this userlist based on the context it is used

func (Userlist) Diff ¶ 

func (s Userlist) Diff(t Userlist, opts ...Options) map[string][]interface{}

Diff checks if two structs of type Userlist are equal

By default empty maps and slices are equal to nil: 

var a, b Userlist
diff := a.Diff(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Userlist
diff := a.Diff(b,Options{
	NilSameAsEmpty: true,
})

func (Userlist) Equal ¶ 

func (s Userlist) Equal(t Userlist, opts ...Options) bool

Equal checks if two structs of type Userlist are equal

By default empty maps and slices are equal to nil: 

var a, b Userlist
equal := a.Equal(b)

For more advanced use case you can configure these options (default values are shown): 

var a, b Userlist
equal := a.Equal(b,Options{
	NilSameAsEmpty: true,
})

func (*Userlist) MarshalBinary ¶ 

func (m *Userlist) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Userlist) MarshalJSON ¶ 

func (m Userlist) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*Userlist) UnmarshalBinary ¶ 

func (m *Userlist) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Userlist) UnmarshalJSON ¶ 

func (m *Userlist) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*Userlist) Validate ¶ 

func (m *Userlist) Validate(formats strfmt.Registry) error

Validate validates this userlist

type UserlistBase ¶ 

type UserlistBase struct {
	// name
	// Required: true
	// Pattern: ^[A-Za-z0-9-_.:]+$
	// +kubebuilder:validation:Pattern=`^[A-Za-z0-9-_.:]+$`
	Name string `json:"name"`
}

UserlistBase Userlist Base

HAProxy configuration of access control ¶

swagger:model userlist_base

func (*UserlistBase) ContextValidate ¶ 

func (m *UserlistBase) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this userlist base based on context it is used

func (UserlistBase) Diff ¶ 

func (s UserlistBase) Diff(t UserlistBase, opts ...Options) map[string][]interface{}

Diff checks if two structs of type UserlistBase are equal 

var a, b UserlistBase
diff := a.Diff(b)

opts ...Options are ignored in this method

func (UserlistBase) Equal ¶ 

func (s UserlistBase) Equal(t UserlistBase, opts ...Options) bool

Equal checks if two structs of type UserlistBase are equal 

var a, b UserlistBase
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*UserlistBase) MarshalBinary ¶ 

func (m *UserlistBase) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*UserlistBase) UnmarshalBinary ¶ 

func (m *UserlistBase) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*UserlistBase) Validate ¶ 

func (m *UserlistBase) Validate(formats strfmt.Registry) error

Validate validates this userlist base

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 ¶ 

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 ¶ 

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 ¶ 

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 ¶ 

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

type WurflOptions ¶ 

type WurflOptions 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"`
}

WurflOptions wurfl options

swagger:model wurfl_options

func (*WurflOptions) ContextValidate ¶ 

func (m *WurflOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this wurfl options based on context it is used

func (WurflOptions) Diff ¶ 

func (s WurflOptions) Diff(t WurflOptions, opts ...Options) map[string][]interface{}

Diff checks if two structs of type WurflOptions are equal 

var a, b WurflOptions
diff := a.Diff(b)

opts ...Options are ignored in this method

func (WurflOptions) Equal ¶ 

func (s WurflOptions) Equal(t WurflOptions, opts ...Options) bool

Equal checks if two structs of type WurflOptions are equal 

var a, b WurflOptions
equal := a.Equal(b)

opts ...Options are ignored in this method

func (*WurflOptions) MarshalBinary ¶ 

func (m *WurflOptions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WurflOptions) UnmarshalBinary ¶ 

func (m *WurflOptions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WurflOptions) Validate ¶ 

func (m *WurflOptions) Validate(formats strfmt.Registry) error

Validate validates this wurfl options

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.