teaconfigs

type ACMEDNSProvider struct {
	// contains filtered or unexported fields
}

type ACMEDNSRecord struct {
	FQDN  string `yaml:"fqdn" json:"fqdn"`
	Value string `yaml:"value" json:"value"`
}

type ACMELocalUser struct {
	Id    string `yaml:"id" json:"id"`
	Name  string `yaml:"name" json:"name"`
	On    bool   `yaml:"on" json:"on"`
	Email string `yaml:"email" json:"email"`
	Key   string `yaml:"key" json:"key"` // base64
	URI   string `yaml:"uri" json:"uri"`
}

type ACMELocalUserList struct {
	Users []*ACMELocalUser `yaml:"users" json:"users"`
}

type ACMERequest struct {
	User *ACMELocalUser `yaml:"user" json:"user"`

	Domains    []string         `yaml:"domains" json:"domains"`
	DNSRecords []*ACMEDNSRecord `yaml:"dnsRecords" json:"dnsRecords"`

	CertURL string `yaml:"certURL" json:"certURL"`
	Cert    string `yaml:"cert" json:"cert"`
	Key     string `yaml:"key" json:"key"`
}

type ACMEUser struct {
	Email        string
	Registration *registration.Resource
	Key          crypto.PrivateKey
}

type AccessLogConfig struct {
	Id string `yaml:"id" json:"id"`
	On bool   `yaml:"on" json:"on"`

	Fields []int `yaml:"fields" json:"fields"` // 记录的字段

	Status1 bool `yaml:"status1" json:"status1"` // 1xx
	Status2 bool `yaml:"status2" json:"status2"` // 2xx
	Status3 bool `yaml:"status3" json:"status3"` // 3xx
	Status4 bool `yaml:"status4" json:"status4"` // 4xx
	Status5 bool `yaml:"status5" json:"status5"` // 5xx

	StorageOnly     bool     `yaml:"storageOnly" json:"storageOnly"`         // 是否只输出到存储策略
	StoragePolicies []string `yaml:"storagePolicies" json:"storagePolicies"` // 存储策略Ids
}

type AccessLogStoragePolicy struct {
	Id      string                 `yaml:"id" json:"id"`
	Name    string                 `yaml:"name" json:"name"`
	On      bool                   `yaml:"bool" json:"on"`
	Type    string                 `yaml:"type" json:"type"`       // 存储类型
	Options map[string]interface{} `yaml:"options" json:"options"` // 存储选项
	Cond    []*shared.RequestCond  `yaml:"cond" json:"cond"`       // 请求条件
}

type AccessLogStoragePolicyList struct {
	Ids []string `yaml:"id" json:"id"`
}

type BackendConfig struct {
	shared.HeaderList `yaml:",inline"`

	TeaVersion string `yaml:"teaVersion" json:"teaVersion"`

	On           bool   `yaml:"on" json:"on"`                     // 是否启用
	Id           string `yaml:"id" json:"id"`                     // ID
	Version      int    `yaml:"version" json:"version"`           // 版本号
	Code         string `yaml:"code" json:"code"`                 // 代号
	Address      string `yaml:"address" json:"address"`           // 地址
	Scheme       string `yaml:"scheme" json:"scheme"`             // 协议，http、https、tcp、tcp+tls、ftp
	Weight       uint   `yaml:"weight" json:"weight"`             // 权重
	IsBackup     bool   `yaml:"backup" json:"isBackup"`           // 是否为备份
	FailTimeout  string `yaml:"failTimeout" json:"failTimeout"`   // 连接失败超时
	ReadTimeout  string `yaml:"readTimeout" json:"readTimeout"`   // 读取超时时间
	IdleTimeout  string `yaml:"idleTimeout" json:"idleTimeout"`   // 空闲连接超时时间
	MaxFails     int32  `yaml:"maxFails" json:"maxFails"`         // 最多失败次数
	CurrentFails int32  `yaml:"currentFails" json:"currentFails"` // 当前已失败次数
	MaxConns     int32  `yaml:"maxConns" json:"maxConns"`         // 最大并发连接数
	CurrentConns int32  `yaml:"currentConns" json:"currentConns"` // 当前连接数
	IdleConns    int32  `yaml:"idleConns" json:"idleConns"`       // 最大空闲连接数

	IsDown   bool      `yaml:"down" json:"isDown"`                           // 是否下线
	DownTime time.Time `yaml:"downTime,omitempty" json:"downTime,omitempty"` // 下线时间

	RequestGroupIds []string               `yaml:"requestGroupIds" json:"requestGroupIds"` // 所属请求分组
	RequestURI      string                 `yaml:"requestURI" json:"requestURI"`           // 转发后的请求URI
	ResponseHeaders []*shared.HeaderConfig `yaml:"responseHeaders" json:"responseHeaders"` // 响应Header
	Host            string                 `yaml:"host" json:"host"`                       // 自定义主机名

	// 健康检查URL，目前支持：
	// - http|https 返回2xx-3xx认为成功
	CheckOn       bool   `yaml:"checkOn" json:"checkOn"` // 是否开启
	CheckURL      string `yaml:"checkURL" json:"checkURL"`
	CheckInterval int    `yaml:"checkInterval" json:"checkInterval"`
	CheckTimeout  string `yaml:"checkTimeout" json:"checkTimeout"` // 超时时间

	Cert *SSLCertConfig `yaml:"cert" json:"cert"` // 请求源服务器用的证书

	// ftp
	FTP *FTPBackendConfig `yaml:"ftp" json:"ftp"`
	// contains filtered or unexported fields
}

type BackendDownEvent struct {
	Server    *ServerConfig
	Backend   *BackendConfig
	Location  *LocationConfig
	Websocket *WebsocketConfig
}

type BackendList struct {
	Backends   []*BackendConfig  `yaml:"backends" json:"backends"`
	Scheduling *SchedulingConfig `yaml:"scheduling" json:"scheduling"` // 调度算法选项
	// contains filtered or unexported fields
}

type BackendListInterface interface {
	// 校验
	ValidateBackends() error

	// 添加Backend
	AddBackend(backend *BackendConfig)

	// 所有的Backends
	AllBackends() []*BackendConfig

	// 删除后端服务器
	DeleteBackend(backendId string)

	// 查找后端服务器
	FindBackend(backendId string) *BackendConfig

	// 调度算法
	SchedulingConfig() *SchedulingConfig

	// 设置调度算法
	SetSchedulingConfig(scheduling *SchedulingConfig)

	// 重新建立调度
	SetupScheduling(isBackup bool)
}

type BackendUpEvent struct {
	Server    *ServerConfig
	Backend   *BackendConfig
	Location  *LocationConfig
	Websocket *WebsocketConfig
}

type Board struct {
	Charts []*BoardChart `yaml:"charts" json:"charts"`
}

type BoardChart struct {
	WidgetId string `yaml:"widgetId" json:"widgetId"`
	ChartId  string `yaml:"chartId" json:"chartId"`
}

type CacheConfig struct {
	Filename    string   `yaml:"filename" json:"filename"`       // 文件名
	PolicyFiles []string `yaml:"policyFiles" json:"policyFiles"` // 策略文件
}

type FTPBackendConfig struct {
	Username string `yaml:"username" json:"username"` // 用户名
	Password string `yaml:"password" json:"password"` // 密码
	Dir      string `yaml:"dir" json:"dir"`           // 目录
}

type FastcgiConfig struct {
	shared.HeaderList `yaml:",inline"`

	On bool   `yaml:"on" json:"on"`
	Id string `yaml:"id" json:"id"`

	// fastcgi地址配置
	// 支持unix:/tmp/php-fpm.sock ...
	Pass string `yaml:"pass" json:"pass"`

	Index           string            `yaml:"index" json:"index"`                     //@TODO
	Params          map[string]string `yaml:"params" json:"params"`                   //@TODO
	ReadTimeout     string            `yaml:"readTimeout" json:"readTimeout"`         // @TODO 读取超时时间
	SendTimeout     string            `yaml:"sendTimeout" json:"sendTimeout"`         // @TODO 发送超时时间
	ConnTimeout     string            `yaml:"connTimeout" json:"connTimeout"`         // @TODO 连接超时时间
	PoolSize        int               `yaml:"poolSize" json:"poolSize"`               // 连接池尺寸
	PathInfoPattern string            `yaml:"pathInfoPattern" json:"pathInfoPattern"` // PATH_INFO匹配正则
	// contains filtered or unexported fields
}

type FastcgiList struct {
	Fastcgi []*FastcgiConfig `yaml:"fastcgi" json:"fastcgi"`
}

type FastcgiListInterface interface {
	// 校验
	ValidateFastcgi() error

	// 取得所有的Fastcgi
	AllFastcgi() []*FastcgiConfig

	// 根据ID查找Fastcgi
	FindFastcgi(fastcgiId string) *FastcgiConfig

	// 添加Fastcgi
	AddFastcgi(fastcgi *FastcgiConfig)

	// 删除Fastcgi
	RemoveFastcgi(fastcgiId string)

	// 查找下一个可用的Fastcgi
	NextFastcgi() *FastcgiConfig
}

type ForwardHTTPConfig struct {
	EnableMITM bool `yaml:"enableMITM" json:"enableMITM"`
}

type GzipConfig struct {
	Level     int8     `yaml:"level" json:"level"`         // 1-9
	MinLength string   `yaml:"minLength" json:"minLength"` // 比如4m, 24k
	MimeTypes []string `yaml:"mimeTypes" json:"mimeTypes"` // 比如text/html, text/*
	// contains filtered or unexported fields
}

type HSTSConfig struct {
	On                bool     `yaml:"on" json:"on"`
	MaxAge            int      `yaml:"maxAge" json:"maxAge"` // 单位秒
	IncludeSubDomains bool     `yaml:"includeSubDomains" json:"includeSubDomains"`
	Preload           bool     `yaml:"preload" json:"preload"`
	Domains           []string `yaml:"domains" json:"domains"`
	// contains filtered or unexported fields
}

type IPRangeList struct {
	IPRanges []*shared.IPRangeConfig
}

type LocationConfig struct {
	shared.HeaderList `yaml:",inline"`
	FastcgiList       `yaml:",inline"`
	RewriteList       `yaml:",inline"`
	BackendList       `yaml:",inline"`

	On      bool   `yaml:"on" json:"on"`           // 是否开启
	Id      string `yaml:"id" json:"id"`           // ID
	Name    string `yaml:"name" json:"name"`       // 名称
	Pattern string `yaml:"pattern" json:"pattern"` // 匹配规则

	Async       bool          `yaml:"async" json:"async"`             // 是否异步请求 @TODO
	Notify      []interface{} `yaml:"notify" json:"notify"`           // 转发请求，可以配置转发策略 @TODO
	LogOnly     bool          `yaml:"logOnly" json:"logOnly"`         // 是否只记录日志 @TODO
	URLPrefix   string        `yaml:"urlPrefix" json:"urlPrefix"`     // 实际的URL前缀，目前和资源根目录配合使用
	Root        string        `yaml:"root" json:"root"`               // 资源根目录
	Index       []string      `yaml:"index" json:"index"`             // 默认文件
	Charset     string        `yaml:"charset" json:"charset"`         // 字符集设置
	MaxBodySize string        `yaml:"maxBodySize" json:"maxBodySize"` // 请求body最大尺寸

	GzipLevel1     int8        `yaml:"gzipLevel" json:"gzipLevel"`         // deprecated v0.1.8 Gzip压缩级别
	GzipMinLength1 string      `yaml:"gzipMinLength" json:"gzipMinLength"` // deprecated v0.1.8 需要压缩的最小内容尺寸
	Gzip           *GzipConfig `yaml:"gzip" json:"gzip"`

	AccessPolicy    *shared.AccessPolicy `yaml:"accessPolicy" json:"accessPolicy"`       // 访问控制
	RedirectToHttps bool                 `yaml:"redirectToHttps" json:"redirectToHttps"` // 是否自动跳转到Https

	// 日志
	AccessLog []*AccessLogConfig `yaml:"accessLog" json:"accessLog"` // 访问日志设置，如果为空表示继承上一级设置

	DisableAccessLog1 bool  `yaml:"disableAccessLog" json:"disableAccessLog"` // deprecated: 是否禁用访问日志
	AccessLogFields1  []int `yaml:"accessLogFields" json:"accessLogFields"`   // deprecated: 访问日志保留的字段，如果为nil，则表示没有设置
	DisableStat       bool  `yaml:"disableStat" json:"disableStat"`           // 是否禁用统计

	// 参考：http://nginx.org/en/docs/http/ngx_http_access_module.html
	Allow []string `yaml:"allow" json:"allow"` // 允许的终端地址 @TODO
	Deny  []string `yaml:"deny" json:"deny"`   // 禁止的终端地址 @TODO

	Proxy string `yaml:"proxy" json:"proxy"` //  代理配置 @TODO

	CachePolicy string `yaml:"cachePolicy" json:"cachePolicy"` // 缓存策略
	CacheOn     bool   `yaml:"cacheOn" json:"cacheOn"`         // 缓存是否打开

	WAFOn bool   `yaml:"wafOn" json:"wafOn"` // 是否启用
	WafId string `yaml:"wafId" json:"wafId"` // WAF ID

	// websocket设置
	Websocket *WebsocketConfig `yaml:"websocket" json:"websocket"`

	// 开启的条件
	// 语法为：cond param operator value 比如：
	// - cond ${status} gte 200
	// - cond ${arg.name} eq lily
	// - cond ${requestPath} regexp .*\.png
	Cond []*shared.RequestCond `yaml:"cond" json:"cond"`

	// 禁止访问的条件
	DenyCond []*shared.RequestCond `yaml:"denyCond" json:"denyCond"`
	DenyAll  bool                  `yaml:"denyAll" json:"denyAll"`

	IsBreak bool `yaml:"isBreak" json:"isBreak"` // 终止向下解析

	Pages           []*PageConfig   `yaml:"pages" json:"pages"`                   // 特殊页
	Shutdown        *ShutdownConfig `yaml:"shutdown" json:"shutdown"`             // 关闭页
	ShutdownPageOn1 bool            `yaml:"shutdownPageOn" json:"shutdownPageOn"` // deprecated: v0.1.8, 是否开启临时关闭页面
	ShutdownPage1   string          `yaml:"shutdownPage" json:"shutdownPage"`     // deprecated: v0.1.8, 临时关闭页面
	// contains filtered or unexported fields
}

type LocationPatternType = int

type MimeTypeRule struct {
	Value  string
	Regexp *regexp.Regexp
}

type NodeConfig struct {
	Id            string   `yaml:"id" json:"id"`                       // ID
	On            bool     `yaml:"on" json:"on"`                       // 是否启用
	Name          string   `yaml:"name" json:"name"`                   // 名称
	ClusterId     string   `yaml:"clusterId" json:"clusterId"`         // 集群ID
	ClusterSecret string   `yaml:"clusterSecret" json:"clusterSecret"` // 集群秘钥
	ClusterAddr   string   `yaml:"clusterAddr" json:"clusterAddr"`     // 集群通讯地址
	Role          NodeRole `yaml:"role" json:"role"`                   // 角色
}

type NodeRole = string

type PageConfig struct {
	On        bool     `yaml:"on" json:"on"`               // TODO
	Status    []string `yaml:"status" json:"status"`       // 响应支持40x, 50x, 3x2
	URL       string   `yaml:"url" json:"url"`             // URL
	NewStatus int      `yaml:"newStatus" json:"newStatus"` // 新状态码
	// contains filtered or unexported fields
}

type ProxySetting struct {
	MatchDomainStrictly bool `yaml:"matchDomainStrictly" json:"matchDomainStrictly"` // 是否严格匹配域名

}

type RequestGroup struct {
	BackendList `yaml:",inline"`

	Id              string                  `yaml:"id" json:"id"`                           // ID
	Name            string                  `yaml:"name" json:"name"`                       // 名称
	Cond            []*shared.RequestCond   `yaml:"conds" json:"conds"`                     // 匹配条件
	IPRanges        []*shared.IPRangeConfig `yaml:"ipRanges" json:"ipRanges"`               // IP范围
	IsDefault       bool                    `yaml:"isDefault" json:"isDefault"`             // 是否为默认分组
	RequestHeaders  []*shared.HeaderConfig  `yaml:"requestHeaders" json:"requestHeaders"`   // 请求Header
	ResponseHeaders []*shared.HeaderConfig  `yaml:"responseHeaders" json:"responseHeaders"` // 响应Header
	// contains filtered or unexported fields
}

type RewriteList struct {
	Rewrite []*RewriteRule `yaml:"rewrite" json:"rewrite"`
}

type RewriteListInterface interface {
	// 校验
	ValidateRewriteRules() error

	// 取得所有的Rewrite
	AllRewriteRules() []*RewriteRule

	// 根据ID查找Rewrite
	FindRewriteRule(rewriteId string) *RewriteRule

	// 添加Rewrite
	AddRewriteRule(rewrite *RewriteRule)

	// 删除Rewrite
	RemoveRewriteRule(rewriteId string)
}

type RewriteRule struct {
	shared.HeaderList `yaml:",inline"`

	On bool   `yaml:"on" json:"on"` // 是否开启
	Id string `yaml:"id" json:"id"` // ID

	// 开启的条件
	// 语法为：cond param operator value 比如：
	// - cond ${status} gte 200
	// - cond ${arg.name} eq lily
	// - cond ${requestPath} regexp .*\.png
	Cond []*shared.RequestCond `yaml:"cond" json:"cond"`

	// 规则
	// 语法为：pattern regexp 比如：
	// - pattern ^/article/(\d+).html
	Pattern string `yaml:"pattern" json:"pattern"`

	// 要替换成的URL
	// 支持反向引用：${0}, ${1}, ...，也支持?P<NAME>语法
	// - 如果以 proxy:// 开头，表示目标为代理，首先会尝试作为代理ID请求，如果找不到，会尝试作为代理Host请求
	Replace string `yaml:"replace" json:"replace"`

	// 选项
	// @TODO 使用具体的语义化的字段代替
	Flags       []string `yaml:"flags" json:"flags"`
	FlagOptions maps.Map `yaml:"flagOptions" json:"flagOptions"` // flag => options map

	IsBreak     bool   `yaml:"isBreak" json:"isBreak"`         // 终止向下解析
	IsPermanent bool   `yaml:"isPermanent" json:"isPermanent"` // 是否持久性跳转
	ProxyHost   string `yaml:"host" json:"host"`               // 代理模式下重写后的Host
	// contains filtered or unexported fields
}

type SSLCertConfig struct {
	Id          string `yaml:"id" json:"id"`
	On          bool   `yaml:"on" json:"on"`
	Description string `yaml:"description" json:"description"` // 说明
	CertFile    string `yaml:"certFile" json:"certFile"`
	KeyFile     string `yaml:"keyFile" json:"keyFile"`
	IsLocal     bool   `yaml:"isLocal" json:"isLocal"`       // 是否为本地文件
	TaskId      string `yaml:"taskId" json:"taskId"`         // 生成证书任务ID
	IsShared    bool   `yaml:"isShared" json:"isShared"`     // 是否为公用组件
	ServerName  string `yaml:"serverName" json:"serverName"` // 证书使用的主机名，在请求TLS服务器时需要
	IsCA        bool   `yaml:"isCA" json:"isCA"`             // 是否为CA证书
	// contains filtered or unexported fields
}

type SSLCertList struct {
	Certs []*SSLCertConfig `yaml:"certs" json:"certs"` // 证书
	Tasks []*SSLCertTask   `yaml:"tasks" json:"tasks"` // 任务
}

type SSLCertTask struct {
	Id       string `yaml:"id" json:"id"`             // ID
	On       bool   `yaml:"on" json:"on"`             // 是否启用
	RunAt    int64  `yaml:"runAt" json:"runAt"`       // 运行时间
	RunError string `yaml:"runError" json:"runError"` // 运行错误

	Request *ACMERequest `yaml:"request" json:"request"` // ACME信息
}

type SSLClientAuthType = int

type SSLConfig struct {
	On bool `yaml:"on" json:"on"` // 是否开启

	Certificate    string `yaml:"certificate" json:"certificate"`       // 证书文件, deprecated in v0.1.4
	CertificateKey string `yaml:"certificateKey" json:"certificateKey"` // 密钥, deprecated in v0.1.4

	Certs           []*SSLCertConfig  `yaml:"certs" json:"certs"`
	CertTasks       []*SSLCertTask    `yaml:"certTasks" json:"certTasks"`
	ClientAuthType  SSLClientAuthType `yaml:"clientAuthType" json:"clientAuthType"`   // 客户端认证类型
	ClientCACertIds []string          `yaml:"clientCACertIds" json:"clientCACertIds"` // 客户端认证CA

	Listen       []string         `yaml:"listen" json:"listen"`             // 网络地址
	MinVersion   TLSVersion       `yaml:"minVersion" json:"minVersion"`     // 支持的最小版本
	CipherSuites []TLSCipherSuite `yaml:"cipherSuites" json:"cipherSuites"` // 加密算法套件

	HSTS          *HSTSConfig `yaml:"hsts2" json:"hsts"`                  // HSTS配置，yaml之所以使用hsts2，是因为要和以前的版本分开
	HTTP2Disabled bool        `yaml:"http2Disabled" json:"http2Disabled"` // 是否禁用HTTP2
	// contains filtered or unexported fields
}

type SchedulingConfig struct {
	Code    string   `yaml:"code" json:"code"`       // 类型
	Options maps.Map `yaml:"options" json:"options"` // 选项
}

type ServerConfig struct {
	shared.HeaderList `yaml:",inline"`
	FastcgiList       `yaml:",inline"`
	RewriteList       `yaml:",inline"`
	BackendList       `yaml:",inline"`

	On bool `yaml:"on" json:"on"`

	Id              string   `yaml:"id" json:"id"`                           // ID
	TeaVersion      string   `yaml:"teaVersion" json:"teaVersion"`           // Tea版本
	Description     string   `yaml:"description" json:"description"`         // 描述
	Name            []string `yaml:"name" json:"name"`                       // 域名
	Http            bool     `yaml:"http" json:"http"`                       // 是否支持HTTP
	RedirectToHttps bool     `yaml:"redirectToHttps" json:"redirectToHttps"` // 是否自动跳转到Https
	IsDefault       bool     `yaml:"isDefault" json:"isDefault"`             // 是否默认的服务，找不到匹配域名时有限使用此配置

	// 监听地址
	Listen []string `yaml:"listen" json:"listen"`

	Root        string            `yaml:"root" json:"root"`               // 资源根目录
	Index       []string          `yaml:"index" json:"index"`             // 默认文件
	Charset     string            `yaml:"charset" json:"charset"`         // 字符集
	Locations   []*LocationConfig `yaml:"locations" json:"locations"`     // 地址配置
	MaxBodySize string            `yaml:"maxBodySize" json:"maxBodySize"` // 请求body最大尺寸

	GzipLevel1     uint8       `yaml:"gzipLevel" json:"gzipLevel"`         // deprecated in v0.1.8: Gzip压缩级别
	GzipMinLength1 string      `yaml:"gzipMinLength" json:"gzipMinLength"` // deprecated in v0.1.8: 需要压缩的最小内容尺寸
	Gzip           *GzipConfig `yaml:"gzip" json:"gzip"`

	// 访问日志
	AccessLog []*AccessLogConfig `yaml:"accessLog" json:"accessLog"` // 访问日志配置

	DisableAccessLog1 bool  `yaml:"disableAccessLog" json:"disableAccessLog"` // deprecated: 是否禁用访问日志
	AccessLogFields1  []int `yaml:"accessLogFields" json:"accessLogFields"`   // deprecated: 访问日志保留的字段，如果为nil，则表示没有设置

	// 统计
	DisableStat bool `yaml:"disableStat" json:"disableStat"` // 是否禁用统计

	// SSL
	SSL *SSLConfig `yaml:"ssl" json:"ssl"`

	// TCP，如果有此配置的说明为TCP代理
	TCP *TCPConfig `yaml:"tcp" json:"tcp"`

	// ForwardHTTP，如果有此配置的说明为正向HTTP代理
	ForwardHTTP *ForwardHTTPConfig `yaml:"forwardHTTP" json:"forwardHTTP"`

	// 参考：http://nginx.org/en/docs/http/ngx_http_access_module.html
	Allow []string `yaml:"allow" json:"allow"` //TODO
	Deny  []string `yaml:"deny" json:"deny"`   //TODO

	Filename string `yaml:"filename" json:"filename"` // 配置文件名

	Proxy string `yaml:"proxy" json:"proxy"` //  代理配置 TODO

	CachePolicy string `yaml:"cachePolicy" json:"cachePolicy"` // 缓存策略
	CacheOn     bool   `yaml:"cacheOn" json:"cacheOn"`         // 缓存是否打开

	WAFOn bool   `yaml:"wafOn" json:"wafOn"` // 是否启用
	WafId string `yaml:"wafId" json:"wafId"` // WAF ID

	// API相关
	API *api.APIConfig `yaml:"api" json:"api"` // API配置

	// 看板
	RealtimeBoard *Board   `yaml:"realtimeBoard" json:"realtimeBoard"` // 即时看板
	StatBoard     *Board   `yaml:"statBoard" json:"statBoard"`         // 统计看板
	StatItems     []string `yaml:"statItems" json:"statItems"`         // 统计指标

	// 是否开启静态文件加速
	CacheStatic bool `yaml:"cacheStatic" json:"cacheStatic"`

	// 请求分组
	RequestGroups []*RequestGroup `yaml:"requestGroups" json:"requestGroups"` // 请求条件分组

	Pages           []*PageConfig   `yaml:"pages" json:"pages"`                   // 特殊页，更高级的需求应该通过Location来设置
	Shutdown        *ShutdownConfig `yaml:"shutdown" json:"shutdown"`             // 关闭页
	ShutdownPageOn1 bool            `yaml:"shutdownPageOn" json:"shutdownPageOn"` // deprecated: v0.1.8, 是否开启临时关闭页面
	ShutdownPage1   string          `yaml:"shutdownPage" json:"shutdownPage"`     // deprecated: v0.1.8, 临时关闭页面

	Version int `yaml:"version" json:"version"` // 版本

	// 隧道相关
	Tunnel *TunnelConfig `yaml:"tunnel" json:"tunnel"`

	// 通知设置
	NoticeSetting map[notices.NoticeLevel][]*notices.NoticeReceiver `yaml:"noticeSetting" json:"noticeSetting"`

	// 通知条目设置
	NoticeItems struct {
		BackendDown *notices.Item `yaml:"backendDown" json:"backendDown"`
		BackendUp   *notices.Item `yaml:"backendUp" json:"backendUp"`
	} `yaml:"noticeItems" json:"noticeItems"`
	// contains filtered or unexported fields
}

type ServerGroup struct {
	Id        string   `yaml:"id" json:"id"`
	IsOn      bool     `yaml:"isOn" json:"isOn"`
	Name      string   `yaml:"name" json:"name"`
	ServerIds []string `yaml:"serverIds" json:"serverIds"`
}

type ServerGroupList struct {
	Groups []*ServerGroup `yaml:"groups" json:"groups"`
}

type ServerList struct {
	Files []string `yaml:"files" json:"files"`
}

type ShutdownConfig struct {
	On     bool   `yaml:"on" json:"on"`
	URL    string `yaml:"url" json:"url"`
	Status int    `yaml:"status" json:"status"`
}

type TCPConfig struct {
	TCPOn           bool `yaml:"tcpOn" json:"tcpOn"`                     // 是否开启TCP
	ReadBufferSize  int  `yaml:"readBufferSize" json:"readBufferSize"`   // 读缓冲区尺寸，默认4K
	WriteBufferSize int  `yaml:"writeBufferSize" json:"writeBufferSize"` // 写缓冲区尺寸，默认4K
}

type TLSCipherSuite = string

type TLSVersion = string

type TimePast = string

type TimeUnit = string

type TunnelConfig struct {
	Id       string           `yaml:"id" json:"id"`             // ID
	On       bool             `yaml:"on" json:"on"`             // 是否启用
	Endpoint string           `yaml:"endpoint" json:"endpoint"` // 终端地址
	Secret   string           `yaml:"secret" json:"secret"`     // 连接用的密钥
	TLS      bool             `yaml:"tls" json:"tls"`           // 是否支持TLS TODO 暂时没有实现
	Certs    []*SSLCertConfig `yaml:"certs" json:"certs"`       // TLS证书 TODO 暂时没有实现
	// contains filtered or unexported fields
}

type WAFList struct {
	Files []string `yaml:"files" json:"files"`
}

type WebConfig struct {
	TeaGo.ServerConfig `yaml:",inline"`

	CertId string `yaml:"certId" json:"certId"` // 代理全局中的证书
}

type WebsocketConfig struct {
	// 后端服务器列表
	BackendList `yaml:",inline"`

	On bool `yaml:"on" json:"on"` // 是否开启

	// 握手超时时间
	HandshakeTimeout string `yaml:"handshakeTimeout" json:"handshakeTimeout"`

	// 允许的域名，支持 www.example.com, example.com, .example.com, *.example.com
	AllowAllOrigins bool     `yaml:"allowAllOrigins" json:"allowAllOrigins"`
	Origins         []string `yaml:"origins" json:"origins"`

	// 转发方式
	ForwardMode WebsocketForwardMode `yaml:"forwardMode" json:"forwardMode"`
	// contains filtered or unexported fields
}

type WebsocketForwardMode = string

type WildcardStatus struct {
	StatusInt    int
	StatusRegexp *regexp.Regexp
}