default_server.go

// Code generated by go-swagger; DO NOT EDIT.

// Copyright 2019 HAProxy Technologies
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

package models

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"encoding/json"
	"strconv"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/strfmt"
	"github.com/go-openapi/swag"
	"github.com/go-openapi/validate"
)

// DefaultServer Default Server
//
// swagger:model default_server
type DefaultServer struct {

	// address
	// Pattern: ^[^\s]+$
	Address string `json:"address,omitempty"`

	// agent addr
	// Pattern: ^[^\s]+$
	AgentAddr string `json:"agent-addr,omitempty"`

	// agent check
	// Enum: [enabled disabled]
	AgentCheck string `json:"agent-check,omitempty"`

	// agent inter
	AgentInter *int64 `json:"agent-inter,omitempty"`

	// agent port
	// Maximum: 65535
	// 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]+$
	Alpn string `json:"alpn,omitempty"`

	// backup
	// Enum: [enabled disabled]
	Backup string `json:"backup,omitempty"`

	// check
	// Enum: [enabled disabled]
	Check string `json:"check,omitempty"`

	// check sni
	// Pattern: ^[^\s]+$
	CheckSni string `json:"check-sni,omitempty"`

	// check ssl
	// Enum: [enabled disabled]
	CheckSsl string `json:"check-ssl,omitempty"`

	// check alpn
	// Pattern: ^[^\s]+$
	CheckAlpn string `json:"check_alpn,omitempty"`

	// check proto
	// Pattern: ^[^\s]+$
	CheckProto string `json:"check_proto,omitempty"`

	// check via socks4
	// Enum: [enabled disabled]
	CheckViaSocks4 string `json:"check_via_socks4,omitempty"`

	// ciphers
	Ciphers string `json:"ciphers,omitempty"`

	// ciphersuites
	Ciphersuites string `json:"ciphersuites,omitempty"`

	// cookie
	// Pattern: ^[^\s]+$
	Cookie string `json:"cookie,omitempty"`

	// crl file
	CrlFile string `json:"crl_file,omitempty"`

	// downinter
	Downinter *int64 `json:"downinter,omitempty"`

	// error limit
	ErrorLimit int64 `json:"error_limit,omitempty"`

	// fall
	Fall *int64 `json:"fall,omitempty"`

	// fastinter
	Fastinter *int64 `json:"fastinter,omitempty"`

	// force sslv3
	// Enum: [enabled disabled]
	ForceSslv3 string `json:"force_sslv3,omitempty"`

	// force tlsv10
	// Enum: [enabled disabled]
	ForceTlsv10 string `json:"force_tlsv10,omitempty"`

	// force tlsv11
	// Enum: [enabled disabled]
	ForceTlsv11 string `json:"force_tlsv11,omitempty"`

	// force tlsv12
	// Enum: [enabled disabled]
	ForceTlsv12 string `json:"force_tlsv12,omitempty"`

	// force tlsv13
	// Enum: [enabled disabled]
	ForceTlsv13 string `json:"force_tlsv13,omitempty"`

	// health check port
	// Maximum: 65535
	// Minimum: 1
	HealthCheckPort *int64 `json:"health_check_port,omitempty"`

	// init addr
	// Pattern: ^[^\s]+$
	InitAddr string `json:"init-addr,omitempty"`

	// inter
	Inter *int64 `json:"inter,omitempty"`

	// log proto
	// Enum: [legacy octet-count]
	LogProto string `json:"log_proto,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"`

	// name
	// Pattern: ^[^\s]+$
	Name string `json:"name,omitempty"`

	// namespace
	Namespace string `json:"namespace,omitempty"`

	// no sslv3
	// Enum: [enabled disabled]
	NoSslv3 string `json:"no_sslv3,omitempty"`

	// no tlsv10
	// Enum: [enabled disabled]
	NoTlsv10 string `json:"no_tlsv10,omitempty"`

	// no tlsv11
	// Enum: [enabled disabled]
	NoTlsv11 string `json:"no_tlsv11,omitempty"`

	// no tlsv12
	// Enum: [enabled disabled]
	NoTlsv12 string `json:"no_tlsv12,omitempty"`

	// no tlsv13
	// Enum: [enabled disabled]
	NoTlsv13 string `json:"no_tlsv13,omitempty"`

	// no verifyhost
	// Enum: [enabled disabled]
	NoVerifyhost string `json:"no_verifyhost,omitempty"`

	// npn
	Npn string `json:"npn,omitempty"`

	// observe
	// Enum: [layer4 layer7]
	Observe string `json:"observe,omitempty"`

	// on error
	// Enum: [fastinter fail-check sudden-death mark-down]
	OnError string `json:"on-error,omitempty"`

	// on marked down
	// Enum: [shutdown-sessions]
	OnMarkedDown string `json:"on-marked-down,omitempty"`

	// on marked up
	// Enum: [shutdown-backup-sessions]
	OnMarkedUp string `json:"on-marked-up,omitempty"`

	// pool low conn
	PoolLowConn *int64 `json:"pool_low_conn,omitempty"`

	// pool max conn
	PoolMaxConn *int64 `json:"pool_max_conn,omitempty"`

	// pool purge delay
	PoolPurgeDelay *int64 `json:"pool_purge_delay,omitempty"`

	// port
	// Maximum: 65535
	// Minimum: 1
	Port *int64 `json:"port,omitempty"`

	// proto
	// Pattern: ^[^\s]+$
	Proto string `json:"proto,omitempty"`

	// proxy v2 options
	ProxyV2Options []string `json:"proxy-v2-options"`

	// redir
	Redir string `json:"redir,omitempty"`

	// resolve net
	// Pattern: ^[^\s]+$
	ResolveNet string `json:"resolve-net,omitempty"`

	// resolve prefer
	// Pattern: ^[^\s]+$
	// Enum: [ipv4 ipv6]
	ResolvePrefer string `json:"resolve-prefer,omitempty"`

	// resolve opts
	// Pattern: ^[^,\s][^\,]*[^,\s]*$
	ResolveOpts string `json:"resolve_opts,omitempty"`

	// resolvers
	// Pattern: ^[^\s]+$
	Resolvers string `json:"resolvers,omitempty"`

	// rise
	Rise *int64 `json:"rise,omitempty"`

	// send proxy
	// Enum: [enabled disabled]
	SendProxy string `json:"send-proxy,omitempty"`

	// send proxy v2
	// Enum: [enabled disabled]
	SendProxyV2 string `json:"send-proxy-v2,omitempty"`

	// send proxy v2 ssl
	// Enum: [enabled disabled]
	SendProxyV2Ssl string `json:"send_proxy_v2_ssl,omitempty"`

	// send proxy v2 ssl cn
	// Enum: [enabled disabled]
	SendProxyV2SslCn string `json:"send_proxy_v2_ssl_cn,omitempty"`

	// slowstart
	Slowstart *int64 `json:"slowstart,omitempty"`

	// sni
	// Pattern: ^[^\s]+$
	Sni string `json:"sni,omitempty"`

	// socks4
	// Pattern: ^[^\s]+$
	Socks4 string `json:"socks4,omitempty"`

	// source
	Source string `json:"source,omitempty"`

	// ssl
	// Enum: [enabled disabled]
	Ssl string `json:"ssl,omitempty"`

	// ssl certificate
	// Pattern: ^[^\s]+$
	SslCertificate string `json:"ssl_certificate,omitempty"`

	// ssl max ver
	// 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]
	SslMinVer string `json:"ssl_min_ver,omitempty"`

	// ssl reuse
	// Enum: [enabled disabled]
	SslReuse string `json:"ssl_reuse,omitempty"`

	// stick
	// Enum: [enabled disabled]
	Stick string `json:"stick,omitempty"`

	// tcp ut
	TCPUt int64 `json:"tcp_ut,omitempty"`

	// tfo
	// Enum: [enabled disabled]
	Tfo string `json:"tfo,omitempty"`

	// tls tickets
	// Enum: [enabled disabled]
	TLSTickets string `json:"tls_tickets,omitempty"`

	// track
	Track string `json:"track,omitempty"`

	// verify
	// Enum: [none required]
	Verify string `json:"verify,omitempty"`

	// verifyhost
	Verifyhost string `json:"verifyhost,omitempty"`

	// weight
	Weight *int64 `json:"weight,omitempty"`
}

// Validate validates this default server
func (m *DefaultServer) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateAddress(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateAgentAddr(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateAgentCheck(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateAgentPort(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateAlpn(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateBackup(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCheck(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCheckSni(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCheckSsl(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCheckAlpn(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCheckProto(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCheckViaSocks4(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCookie(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateForceSslv3(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateForceTlsv10(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateForceTlsv11(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateForceTlsv12(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateForceTlsv13(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateHealthCheckPort(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateInitAddr(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateLogProto(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateName(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateNoSslv3(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateNoTlsv10(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateNoTlsv11(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateNoTlsv12(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateNoTlsv13(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateNoVerifyhost(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateObserve(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateOnError(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateOnMarkedDown(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateOnMarkedUp(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validatePort(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateProto(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateProxyV2Options(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateResolveNet(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateResolvePrefer(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateResolveOpts(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateResolvers(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSendProxy(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSendProxyV2(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSendProxyV2Ssl(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSendProxyV2SslCn(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSni(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSocks4(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSsl(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSslCertificate(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSslMaxVer(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSslMinVer(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSslReuse(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateStick(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateTfo(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateTLSTickets(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateVerify(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *DefaultServer) validateAddress(formats strfmt.Registry) error {

	if swag.IsZero(m.Address) { // not required
		return nil
	}

	if err := validate.Pattern("address", "body", string(m.Address), `^[^\s]+$`); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateAgentAddr(formats strfmt.Registry) error {

	if swag.IsZero(m.AgentAddr) { // not required
		return nil
	}

	if err := validate.Pattern("agent-addr", "body", string(m.AgentAddr), `^[^\s]+$`); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeAgentCheckPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeAgentCheckPropEnum = append(defaultServerTypeAgentCheckPropEnum, v)
	}
}

const (

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

	// DefaultServerAgentCheckDisabled captures enum value "disabled"
	DefaultServerAgentCheckDisabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateAgentCheckEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeAgentCheckPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateAgentCheck(formats strfmt.Registry) error {

	if swag.IsZero(m.AgentCheck) { // not required
		return nil
	}

	// value enum
	if err := m.validateAgentCheckEnum("agent-check", "body", m.AgentCheck); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateAgentPort(formats strfmt.Registry) error {

	if swag.IsZero(m.AgentPort) { // not required
		return nil
	}

	if err := validate.MinimumInt("agent-port", "body", int64(*m.AgentPort), 1, false); err != nil {
		return err
	}

	if err := validate.MaximumInt("agent-port", "body", int64(*m.AgentPort), 65535, false); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateAlpn(formats strfmt.Registry) error {

	if swag.IsZero(m.Alpn) { // not required
		return nil
	}

	if err := validate.Pattern("alpn", "body", string(m.Alpn), `^[^\s]+$`); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeBackupPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeBackupPropEnum = append(defaultServerTypeBackupPropEnum, v)
	}
}

const (

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

	// DefaultServerBackupDisabled captures enum value "disabled"
	DefaultServerBackupDisabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateBackupEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeBackupPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateBackup(formats strfmt.Registry) error {

	if swag.IsZero(m.Backup) { // not required
		return nil
	}

	// value enum
	if err := m.validateBackupEnum("backup", "body", m.Backup); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeCheckPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeCheckPropEnum = append(defaultServerTypeCheckPropEnum, v)
	}
}

const (

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

	// DefaultServerCheckDisabled captures enum value "disabled"
	DefaultServerCheckDisabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateCheckEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeCheckPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateCheck(formats strfmt.Registry) error {

	if swag.IsZero(m.Check) { // not required
		return nil
	}

	// value enum
	if err := m.validateCheckEnum("check", "body", m.Check); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateCheckSni(formats strfmt.Registry) error {

	if swag.IsZero(m.CheckSni) { // not required
		return nil
	}

	if err := validate.Pattern("check-sni", "body", string(m.CheckSni), `^[^\s]+$`); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeCheckSslPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeCheckSslPropEnum = append(defaultServerTypeCheckSslPropEnum, v)
	}
}

const (

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

	// DefaultServerCheckSslDisabled captures enum value "disabled"
	DefaultServerCheckSslDisabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateCheckSslEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeCheckSslPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateCheckSsl(formats strfmt.Registry) error {

	if swag.IsZero(m.CheckSsl) { // not required
		return nil
	}

	// value enum
	if err := m.validateCheckSslEnum("check-ssl", "body", m.CheckSsl); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateCheckAlpn(formats strfmt.Registry) error {

	if swag.IsZero(m.CheckAlpn) { // not required
		return nil
	}

	if err := validate.Pattern("check_alpn", "body", string(m.CheckAlpn), `^[^\s]+$`); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateCheckProto(formats strfmt.Registry) error {

	if swag.IsZero(m.CheckProto) { // not required
		return nil
	}

	if err := validate.Pattern("check_proto", "body", string(m.CheckProto), `^[^\s]+$`); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeCheckViaSocks4PropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeCheckViaSocks4PropEnum = append(defaultServerTypeCheckViaSocks4PropEnum, v)
	}
}

const (

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

	// DefaultServerCheckViaSocks4Disabled captures enum value "disabled"
	DefaultServerCheckViaSocks4Disabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateCheckViaSocks4Enum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeCheckViaSocks4PropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateCheckViaSocks4(formats strfmt.Registry) error {

	if swag.IsZero(m.CheckViaSocks4) { // not required
		return nil
	}

	// value enum
	if err := m.validateCheckViaSocks4Enum("check_via_socks4", "body", m.CheckViaSocks4); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateCookie(formats strfmt.Registry) error {

	if swag.IsZero(m.Cookie) { // not required
		return nil
	}

	if err := validate.Pattern("cookie", "body", string(m.Cookie), `^[^\s]+$`); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeForceSslv3PropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeForceSslv3PropEnum = append(defaultServerTypeForceSslv3PropEnum, v)
	}
}

const (

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

	// DefaultServerForceSslv3Disabled captures enum value "disabled"
	DefaultServerForceSslv3Disabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateForceSslv3Enum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeForceSslv3PropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateForceSslv3(formats strfmt.Registry) error {

	if swag.IsZero(m.ForceSslv3) { // not required
		return nil
	}

	// value enum
	if err := m.validateForceSslv3Enum("force_sslv3", "body", m.ForceSslv3); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeForceTlsv10PropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeForceTlsv10PropEnum = append(defaultServerTypeForceTlsv10PropEnum, v)
	}
}

const (

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

	// DefaultServerForceTlsv10Disabled captures enum value "disabled"
	DefaultServerForceTlsv10Disabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateForceTlsv10Enum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeForceTlsv10PropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateForceTlsv10(formats strfmt.Registry) error {

	if swag.IsZero(m.ForceTlsv10) { // not required
		return nil
	}

	// value enum
	if err := m.validateForceTlsv10Enum("force_tlsv10", "body", m.ForceTlsv10); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeForceTlsv11PropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeForceTlsv11PropEnum = append(defaultServerTypeForceTlsv11PropEnum, v)
	}
}

const (

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

	// DefaultServerForceTlsv11Disabled captures enum value "disabled"
	DefaultServerForceTlsv11Disabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateForceTlsv11Enum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeForceTlsv11PropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateForceTlsv11(formats strfmt.Registry) error {

	if swag.IsZero(m.ForceTlsv11) { // not required
		return nil
	}

	// value enum
	if err := m.validateForceTlsv11Enum("force_tlsv11", "body", m.ForceTlsv11); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeForceTlsv12PropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeForceTlsv12PropEnum = append(defaultServerTypeForceTlsv12PropEnum, v)
	}
}

const (

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

	// DefaultServerForceTlsv12Disabled captures enum value "disabled"
	DefaultServerForceTlsv12Disabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateForceTlsv12Enum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeForceTlsv12PropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateForceTlsv12(formats strfmt.Registry) error {

	if swag.IsZero(m.ForceTlsv12) { // not required
		return nil
	}

	// value enum
	if err := m.validateForceTlsv12Enum("force_tlsv12", "body", m.ForceTlsv12); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeForceTlsv13PropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeForceTlsv13PropEnum = append(defaultServerTypeForceTlsv13PropEnum, v)
	}
}

const (

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

	// DefaultServerForceTlsv13Disabled captures enum value "disabled"
	DefaultServerForceTlsv13Disabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateForceTlsv13Enum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeForceTlsv13PropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateForceTlsv13(formats strfmt.Registry) error {

	if swag.IsZero(m.ForceTlsv13) { // not required
		return nil
	}

	// value enum
	if err := m.validateForceTlsv13Enum("force_tlsv13", "body", m.ForceTlsv13); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateHealthCheckPort(formats strfmt.Registry) error {

	if swag.IsZero(m.HealthCheckPort) { // not required
		return nil
	}

	if err := validate.MinimumInt("health_check_port", "body", int64(*m.HealthCheckPort), 1, false); err != nil {
		return err
	}

	if err := validate.MaximumInt("health_check_port", "body", int64(*m.HealthCheckPort), 65535, false); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateInitAddr(formats strfmt.Registry) error {

	if swag.IsZero(m.InitAddr) { // not required
		return nil
	}

	if err := validate.Pattern("init-addr", "body", string(m.InitAddr), `^[^\s]+$`); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeLogProtoPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["legacy","octet-count"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeLogProtoPropEnum = append(defaultServerTypeLogProtoPropEnum, v)
	}
}

const (

	// DefaultServerLogProtoLegacy captures enum value "legacy"
	DefaultServerLogProtoLegacy string = "legacy"

	// DefaultServerLogProtoOctetCount captures enum value "octet-count"
	DefaultServerLogProtoOctetCount string = "octet-count"
)

// prop value enum
func (m *DefaultServer) validateLogProtoEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeLogProtoPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateLogProto(formats strfmt.Registry) error {

	if swag.IsZero(m.LogProto) { // not required
		return nil
	}

	// value enum
	if err := m.validateLogProtoEnum("log_proto", "body", m.LogProto); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateName(formats strfmt.Registry) error {

	if swag.IsZero(m.Name) { // not required
		return nil
	}

	if err := validate.Pattern("name", "body", string(m.Name), `^[^\s]+$`); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeNoSslv3PropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeNoSslv3PropEnum = append(defaultServerTypeNoSslv3PropEnum, v)
	}
}

const (

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

	// DefaultServerNoSslv3Disabled captures enum value "disabled"
	DefaultServerNoSslv3Disabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateNoSslv3Enum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeNoSslv3PropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateNoSslv3(formats strfmt.Registry) error {

	if swag.IsZero(m.NoSslv3) { // not required
		return nil
	}

	// value enum
	if err := m.validateNoSslv3Enum("no_sslv3", "body", m.NoSslv3); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeNoTlsv10PropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeNoTlsv10PropEnum = append(defaultServerTypeNoTlsv10PropEnum, v)
	}
}

const (

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

	// DefaultServerNoTlsv10Disabled captures enum value "disabled"
	DefaultServerNoTlsv10Disabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateNoTlsv10Enum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeNoTlsv10PropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateNoTlsv10(formats strfmt.Registry) error {

	if swag.IsZero(m.NoTlsv10) { // not required
		return nil
	}

	// value enum
	if err := m.validateNoTlsv10Enum("no_tlsv10", "body", m.NoTlsv10); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeNoTlsv11PropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeNoTlsv11PropEnum = append(defaultServerTypeNoTlsv11PropEnum, v)
	}
}

const (

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

	// DefaultServerNoTlsv11Disabled captures enum value "disabled"
	DefaultServerNoTlsv11Disabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateNoTlsv11Enum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeNoTlsv11PropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateNoTlsv11(formats strfmt.Registry) error {

	if swag.IsZero(m.NoTlsv11) { // not required
		return nil
	}

	// value enum
	if err := m.validateNoTlsv11Enum("no_tlsv11", "body", m.NoTlsv11); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeNoTlsv12PropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeNoTlsv12PropEnum = append(defaultServerTypeNoTlsv12PropEnum, v)
	}
}

const (

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

	// DefaultServerNoTlsv12Disabled captures enum value "disabled"
	DefaultServerNoTlsv12Disabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateNoTlsv12Enum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeNoTlsv12PropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateNoTlsv12(formats strfmt.Registry) error {

	if swag.IsZero(m.NoTlsv12) { // not required
		return nil
	}

	// value enum
	if err := m.validateNoTlsv12Enum("no_tlsv12", "body", m.NoTlsv12); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeNoTlsv13PropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeNoTlsv13PropEnum = append(defaultServerTypeNoTlsv13PropEnum, v)
	}
}

const (

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

	// DefaultServerNoTlsv13Disabled captures enum value "disabled"
	DefaultServerNoTlsv13Disabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateNoTlsv13Enum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeNoTlsv13PropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateNoTlsv13(formats strfmt.Registry) error {

	if swag.IsZero(m.NoTlsv13) { // not required
		return nil
	}

	// value enum
	if err := m.validateNoTlsv13Enum("no_tlsv13", "body", m.NoTlsv13); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeNoVerifyhostPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeNoVerifyhostPropEnum = append(defaultServerTypeNoVerifyhostPropEnum, v)
	}
}

const (

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

	// DefaultServerNoVerifyhostDisabled captures enum value "disabled"
	DefaultServerNoVerifyhostDisabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateNoVerifyhostEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeNoVerifyhostPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateNoVerifyhost(formats strfmt.Registry) error {

	if swag.IsZero(m.NoVerifyhost) { // not required
		return nil
	}

	// value enum
	if err := m.validateNoVerifyhostEnum("no_verifyhost", "body", m.NoVerifyhost); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeObservePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["layer4","layer7"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeObservePropEnum = append(defaultServerTypeObservePropEnum, v)
	}
}

const (

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

	// DefaultServerObserveLayer7 captures enum value "layer7"
	DefaultServerObserveLayer7 string = "layer7"
)

// prop value enum
func (m *DefaultServer) validateObserveEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeObservePropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateObserve(formats strfmt.Registry) error {

	if swag.IsZero(m.Observe) { // not required
		return nil
	}

	// value enum
	if err := m.validateObserveEnum("observe", "body", m.Observe); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeOnErrorPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["fastinter","fail-check","sudden-death","mark-down"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeOnErrorPropEnum = append(defaultServerTypeOnErrorPropEnum, v)
	}
}

const (

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

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

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

	// DefaultServerOnErrorMarkDown captures enum value "mark-down"
	DefaultServerOnErrorMarkDown string = "mark-down"
)

// prop value enum
func (m *DefaultServer) validateOnErrorEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeOnErrorPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateOnError(formats strfmt.Registry) error {

	if swag.IsZero(m.OnError) { // not required
		return nil
	}

	// value enum
	if err := m.validateOnErrorEnum("on-error", "body", m.OnError); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeOnMarkedDownPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["shutdown-sessions"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeOnMarkedDownPropEnum = append(defaultServerTypeOnMarkedDownPropEnum, v)
	}
}

const (

	// DefaultServerOnMarkedDownShutdownSessions captures enum value "shutdown-sessions"
	DefaultServerOnMarkedDownShutdownSessions string = "shutdown-sessions"
)

// prop value enum
func (m *DefaultServer) validateOnMarkedDownEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeOnMarkedDownPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateOnMarkedDown(formats strfmt.Registry) error {

	if swag.IsZero(m.OnMarkedDown) { // not required
		return nil
	}

	// value enum
	if err := m.validateOnMarkedDownEnum("on-marked-down", "body", m.OnMarkedDown); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeOnMarkedUpPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["shutdown-backup-sessions"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeOnMarkedUpPropEnum = append(defaultServerTypeOnMarkedUpPropEnum, v)
	}
}

const (

	// DefaultServerOnMarkedUpShutdownBackupSessions captures enum value "shutdown-backup-sessions"
	DefaultServerOnMarkedUpShutdownBackupSessions string = "shutdown-backup-sessions"
)

// prop value enum
func (m *DefaultServer) validateOnMarkedUpEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeOnMarkedUpPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateOnMarkedUp(formats strfmt.Registry) error {

	if swag.IsZero(m.OnMarkedUp) { // not required
		return nil
	}

	// value enum
	if err := m.validateOnMarkedUpEnum("on-marked-up", "body", m.OnMarkedUp); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validatePort(formats strfmt.Registry) error {

	if swag.IsZero(m.Port) { // not required
		return nil
	}

	if err := validate.MinimumInt("port", "body", int64(*m.Port), 1, false); err != nil {
		return err
	}

	if err := validate.MaximumInt("port", "body", int64(*m.Port), 65535, false); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateProto(formats strfmt.Registry) error {

	if swag.IsZero(m.Proto) { // not required
		return nil
	}

	if err := validate.Pattern("proto", "body", string(m.Proto), `^[^\s]+$`); err != nil {
		return err
	}

	return nil
}

var defaultServerProxyV2OptionsItemsEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["ssl","cert-cn","ssl-cipher","cert-sig","cert-key","authority","crc32c","unique-id"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerProxyV2OptionsItemsEnum = append(defaultServerProxyV2OptionsItemsEnum, v)
	}
}

func (m *DefaultServer) validateProxyV2OptionsItemsEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerProxyV2OptionsItemsEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateProxyV2Options(formats strfmt.Registry) error {

	if swag.IsZero(m.ProxyV2Options) { // not required
		return nil
	}

	for i := 0; i < len(m.ProxyV2Options); i++ {

		// value enum
		if err := m.validateProxyV2OptionsItemsEnum("proxy-v2-options"+"."+strconv.Itoa(i), "body", m.ProxyV2Options[i]); err != nil {
			return err
		}

	}

	return nil
}

func (m *DefaultServer) validateResolveNet(formats strfmt.Registry) error {

	if swag.IsZero(m.ResolveNet) { // not required
		return nil
	}

	if err := validate.Pattern("resolve-net", "body", string(m.ResolveNet), `^[^\s]+$`); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeResolvePreferPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["ipv4","ipv6"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeResolvePreferPropEnum = append(defaultServerTypeResolvePreferPropEnum, v)
	}
}

const (

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

	// DefaultServerResolvePreferIPV6 captures enum value "ipv6"
	DefaultServerResolvePreferIPV6 string = "ipv6"
)

// prop value enum
func (m *DefaultServer) validateResolvePreferEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeResolvePreferPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateResolvePrefer(formats strfmt.Registry) error {

	if swag.IsZero(m.ResolvePrefer) { // not required
		return nil
	}

	if err := validate.Pattern("resolve-prefer", "body", string(m.ResolvePrefer), `^[^\s]+$`); err != nil {
		return err
	}

	// value enum
	if err := m.validateResolvePreferEnum("resolve-prefer", "body", m.ResolvePrefer); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateResolveOpts(formats strfmt.Registry) error {

	if swag.IsZero(m.ResolveOpts) { // not required
		return nil
	}

	if err := validate.Pattern("resolve_opts", "body", string(m.ResolveOpts), `^[^,\s][^\,]*[^,\s]*$`); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateResolvers(formats strfmt.Registry) error {

	if swag.IsZero(m.Resolvers) { // not required
		return nil
	}

	if err := validate.Pattern("resolvers", "body", string(m.Resolvers), `^[^\s]+$`); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeSendProxyPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeSendProxyPropEnum = append(defaultServerTypeSendProxyPropEnum, v)
	}
}

const (

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

	// DefaultServerSendProxyDisabled captures enum value "disabled"
	DefaultServerSendProxyDisabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateSendProxyEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeSendProxyPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateSendProxy(formats strfmt.Registry) error {

	if swag.IsZero(m.SendProxy) { // not required
		return nil
	}

	// value enum
	if err := m.validateSendProxyEnum("send-proxy", "body", m.SendProxy); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeSendProxyV2PropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeSendProxyV2PropEnum = append(defaultServerTypeSendProxyV2PropEnum, v)
	}
}

const (

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

	// DefaultServerSendProxyV2Disabled captures enum value "disabled"
	DefaultServerSendProxyV2Disabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateSendProxyV2Enum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeSendProxyV2PropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateSendProxyV2(formats strfmt.Registry) error {

	if swag.IsZero(m.SendProxyV2) { // not required
		return nil
	}

	// value enum
	if err := m.validateSendProxyV2Enum("send-proxy-v2", "body", m.SendProxyV2); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeSendProxyV2SslPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeSendProxyV2SslPropEnum = append(defaultServerTypeSendProxyV2SslPropEnum, v)
	}
}

const (

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

	// DefaultServerSendProxyV2SslDisabled captures enum value "disabled"
	DefaultServerSendProxyV2SslDisabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateSendProxyV2SslEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeSendProxyV2SslPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateSendProxyV2Ssl(formats strfmt.Registry) error {

	if swag.IsZero(m.SendProxyV2Ssl) { // not required
		return nil
	}

	// value enum
	if err := m.validateSendProxyV2SslEnum("send_proxy_v2_ssl", "body", m.SendProxyV2Ssl); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeSendProxyV2SslCnPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeSendProxyV2SslCnPropEnum = append(defaultServerTypeSendProxyV2SslCnPropEnum, v)
	}
}

const (

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

	// DefaultServerSendProxyV2SslCnDisabled captures enum value "disabled"
	DefaultServerSendProxyV2SslCnDisabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateSendProxyV2SslCnEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeSendProxyV2SslCnPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateSendProxyV2SslCn(formats strfmt.Registry) error {

	if swag.IsZero(m.SendProxyV2SslCn) { // not required
		return nil
	}

	// value enum
	if err := m.validateSendProxyV2SslCnEnum("send_proxy_v2_ssl_cn", "body", m.SendProxyV2SslCn); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateSni(formats strfmt.Registry) error {

	if swag.IsZero(m.Sni) { // not required
		return nil
	}

	if err := validate.Pattern("sni", "body", string(m.Sni), `^[^\s]+$`); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateSocks4(formats strfmt.Registry) error {

	if swag.IsZero(m.Socks4) { // not required
		return nil
	}

	if err := validate.Pattern("socks4", "body", string(m.Socks4), `^[^\s]+$`); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeSslPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeSslPropEnum = append(defaultServerTypeSslPropEnum, v)
	}
}

const (

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

	// DefaultServerSslDisabled captures enum value "disabled"
	DefaultServerSslDisabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateSslEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeSslPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateSsl(formats strfmt.Registry) error {

	if swag.IsZero(m.Ssl) { // not required
		return nil
	}

	// value enum
	if err := m.validateSslEnum("ssl", "body", m.Ssl); err != nil {
		return err
	}

	return nil
}

func (m *DefaultServer) validateSslCertificate(formats strfmt.Registry) error {

	if swag.IsZero(m.SslCertificate) { // not required
		return nil
	}

	if err := validate.Pattern("ssl_certificate", "body", string(m.SslCertificate), `^[^\s]+$`); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeSslMaxVerPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["SSLv3","TLSv1.0","TLSv1.1","TLSv1.2","TLSv1.3"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeSslMaxVerPropEnum = append(defaultServerTypeSslMaxVerPropEnum, v)
	}
}

const (

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

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

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

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

	// DefaultServerSslMaxVerTLSv13 captures enum value "TLSv1.3"
	DefaultServerSslMaxVerTLSv13 string = "TLSv1.3"
)

// prop value enum
func (m *DefaultServer) validateSslMaxVerEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeSslMaxVerPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateSslMaxVer(formats strfmt.Registry) error {

	if swag.IsZero(m.SslMaxVer) { // not required
		return nil
	}

	// value enum
	if err := m.validateSslMaxVerEnum("ssl_max_ver", "body", m.SslMaxVer); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeSslMinVerPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["SSLv3","TLSv1.0","TLSv1.1","TLSv1.2","TLSv1.3"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeSslMinVerPropEnum = append(defaultServerTypeSslMinVerPropEnum, v)
	}
}

const (

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

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

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

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

	// DefaultServerSslMinVerTLSv13 captures enum value "TLSv1.3"
	DefaultServerSslMinVerTLSv13 string = "TLSv1.3"
)

// prop value enum
func (m *DefaultServer) validateSslMinVerEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeSslMinVerPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateSslMinVer(formats strfmt.Registry) error {

	if swag.IsZero(m.SslMinVer) { // not required
		return nil
	}

	// value enum
	if err := m.validateSslMinVerEnum("ssl_min_ver", "body", m.SslMinVer); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeSslReusePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeSslReusePropEnum = append(defaultServerTypeSslReusePropEnum, v)
	}
}

const (

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

	// DefaultServerSslReuseDisabled captures enum value "disabled"
	DefaultServerSslReuseDisabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateSslReuseEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeSslReusePropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateSslReuse(formats strfmt.Registry) error {

	if swag.IsZero(m.SslReuse) { // not required
		return nil
	}

	// value enum
	if err := m.validateSslReuseEnum("ssl_reuse", "body", m.SslReuse); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeStickPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeStickPropEnum = append(defaultServerTypeStickPropEnum, v)
	}
}

const (

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

	// DefaultServerStickDisabled captures enum value "disabled"
	DefaultServerStickDisabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateStickEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeStickPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateStick(formats strfmt.Registry) error {

	if swag.IsZero(m.Stick) { // not required
		return nil
	}

	// value enum
	if err := m.validateStickEnum("stick", "body", m.Stick); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeTfoPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeTfoPropEnum = append(defaultServerTypeTfoPropEnum, v)
	}
}

const (

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

	// DefaultServerTfoDisabled captures enum value "disabled"
	DefaultServerTfoDisabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateTfoEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeTfoPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateTfo(formats strfmt.Registry) error {

	if swag.IsZero(m.Tfo) { // not required
		return nil
	}

	// value enum
	if err := m.validateTfoEnum("tfo", "body", m.Tfo); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeTLSTicketsPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["enabled","disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeTLSTicketsPropEnum = append(defaultServerTypeTLSTicketsPropEnum, v)
	}
}

const (

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

	// DefaultServerTLSTicketsDisabled captures enum value "disabled"
	DefaultServerTLSTicketsDisabled string = "disabled"
)

// prop value enum
func (m *DefaultServer) validateTLSTicketsEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeTLSTicketsPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateTLSTickets(formats strfmt.Registry) error {

	if swag.IsZero(m.TLSTickets) { // not required
		return nil
	}

	// value enum
	if err := m.validateTLSTicketsEnum("tls_tickets", "body", m.TLSTickets); err != nil {
		return err
	}

	return nil
}

var defaultServerTypeVerifyPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["none","required"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		defaultServerTypeVerifyPropEnum = append(defaultServerTypeVerifyPropEnum, v)
	}
}

const (

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

	// DefaultServerVerifyRequired captures enum value "required"
	DefaultServerVerifyRequired string = "required"
)

// prop value enum
func (m *DefaultServer) validateVerifyEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, defaultServerTypeVerifyPropEnum); err != nil {
		return err
	}
	return nil
}

func (m *DefaultServer) validateVerify(formats strfmt.Registry) error {

	if swag.IsZero(m.Verify) { // not required
		return nil
	}

	// value enum
	if err := m.validateVerifyEnum("verify", "body", m.Verify); err != nil {
		return err
	}

	return nil
}

// MarshalBinary interface implementation
func (m *DefaultServer) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *DefaultServer) UnmarshalBinary(b []byte) error {
	var res DefaultServer
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}