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

// Server Server
//
// HAProxy backend server configuration
//
// swagger:model server
type Server 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"`

	// id
	ID *int64 `json:"id,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"`

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

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

	// 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][^\,]*[^,\s]*$
	ResolveNet string `json:"resolve-net,omitempty"`

	// resolve prefer
	// 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 cafile
	// Pattern: ^[^\s]+$
	SslCafile string `json:"ssl_cafile,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 server
func (m *Server) 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.validateMaintenance(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.validateSslCafile(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 *Server) 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 *Server) 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 serverTypeAgentCheckPropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 *Server) 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 *Server) 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 serverTypeBackupPropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeCheckPropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 *Server) 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 serverTypeCheckSslPropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 *Server) 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 *Server) 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 serverTypeCheckViaSocks4PropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 *Server) 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 serverTypeForceSslv3PropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeForceTlsv10PropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeForceTlsv11PropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeForceTlsv12PropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeForceTlsv13PropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 *Server) 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 *Server) 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 serverTypeLogProtoPropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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
}

var serverTypeMaintenancePropEnum []interface{}

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

const (

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

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

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

func (m *Server) validateMaintenance(formats strfmt.Registry) error {

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

	// value enum
	if err := m.validateMaintenanceEnum("maintenance", "body", m.Maintenance); err != nil {
		return err
	}

	return nil
}

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

	if err := validate.RequiredString("name", "body", string(m.Name)); err != nil {
		return err
	}

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

	return nil
}

var serverTypeNoSslv3PropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeNoTlsv10PropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeNoTlsv11PropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeNoTlsv12PropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeNoTlsv13PropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeNoVerifyhostPropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeObservePropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeOnErrorPropEnum []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 {
		serverTypeOnErrorPropEnum = append(serverTypeOnErrorPropEnum, v)
	}
}

const (

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

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

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

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

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

func (m *Server) 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 serverTypeOnMarkedDownPropEnum []interface{}

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

const (

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

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

func (m *Server) 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 serverTypeOnMarkedUpPropEnum []interface{}

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

const (

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

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

func (m *Server) 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 *Server) 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 *Server) 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 serverProxyV2OptionsItemsEnum []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 {
		serverProxyV2OptionsItemsEnum = append(serverProxyV2OptionsItemsEnum, v)
	}
}

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

func (m *Server) 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 *Server) 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][^\,]*[^,\s]*$`); err != nil {
		return err
	}

	return nil
}

var serverTypeResolvePreferPropEnum []interface{}

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

const (

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

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

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

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

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

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

	return nil
}

func (m *Server) 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 *Server) 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 serverTypeSendProxyPropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeSendProxyV2PropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeSendProxyV2SslPropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeSendProxyV2SslCnPropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 *Server) 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 *Server) 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 serverTypeSslPropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 *Server) validateSslCafile(formats strfmt.Registry) error {

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

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

	return nil
}

func (m *Server) 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 serverTypeSslMaxVerPropEnum []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 {
		serverTypeSslMaxVerPropEnum = append(serverTypeSslMaxVerPropEnum, v)
	}
}

const (

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

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

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

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

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

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

func (m *Server) 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 serverTypeSslMinVerPropEnum []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 {
		serverTypeSslMinVerPropEnum = append(serverTypeSslMinVerPropEnum, v)
	}
}

const (

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

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

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

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

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

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

func (m *Server) 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 serverTypeSslReusePropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeStickPropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeTfoPropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeTLSTicketsPropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 serverTypeVerifyPropEnum []interface{}

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

const (

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

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

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

func (m *Server) 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 *Server) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

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