serverconfigs

type AccessLogCommandStorageConfig struct {
	Command string   `yaml:"command" json:"command"`
	Args    []string `yaml:"args" json:"args"`
	Dir     string   `yaml:"dir" json:"dir"`
}

type AccessLogESStorageConfig struct {
	Endpoint     string `yaml:"endpoint" json:"endpoint"`
	Index        string `yaml:"index" json:"index"`
	MappingType  string `yaml:"mappingType" json:"mappingType"`
	Username     string `yaml:"username" json:"username"`
	Password     string `yaml:"password" json:"password"`
	IsDataStream bool   `yaml:"isDataStream" json:"isDataStream"` // 是否为Data Stream模式
}

type AccessLogFileStorageConfig struct {
	Path       string `yaml:"path" json:"path"`             // 文件路径，支持变量：${year|month|week|day|hour|minute|second}
	AutoCreate bool   `yaml:"autoCreate" json:"autoCreate"` // 是否自动创建目录
}

type AccessLogQueueConfig struct {
	MaxLength      int `yaml:"maxLength" json:"maxLength"`           // 队列最大长度
	CountPerSecond int `yaml:"countPerSecond" json:"countPerSecond"` // 每秒写入数量
	Percent        int `yaml:"percent" json:"percent"`               // 比例，如果为0-100，默认为100

	EnableAutoPartial bool  `yaml:"enableAutoPartial" json:"enableAutoPartial"` // 是否启动自动分表
	RowsPerTable      int64 `yaml:"rowsPerTable" json:"rowsPerTable"`           // 单表最大行数
}

type AccessLogStorageType = string

type AccessLogSyslogStorageConfig struct {
	Protocol   string                         `yaml:"protocol" json:"protocol"` // SysLogStorageProtocol*
	ServerAddr string                         `yaml:"serverAddr" json:"serverAddr"`
	ServerPort int                            `yaml:"serverPort" json:"serverPort"`
	Socket     string                         `yaml:"socket" json:"socket"` // sock file
	Tag        string                         `yaml:"tag" json:"tag"`
	Priority   AccessLogSyslogStoragePriority `yaml:"priority" json:"priority"`
}

type AccessLogSyslogStoragePriority = int

type AccessLogSyslogStorageProtocol = string

type AccessLogTCPStorageConfig struct {
	Network string `yaml:"network" json:"network"` // tcp, unix
	Addr    string `yaml:"addr" json:"addr"`
}

type BaseProtocol struct {
	IsOn   bool                    `yaml:"isOn" json:"isOn"`     // 是否开启
	Listen []*NetworkAddressConfig `yaml:"listen" json:"listen"` // 绑定的网络地址
}

type CacheDir struct {
	Path     string               `yaml:"path" json:"path"`         // 目录
	Capacity *shared.SizeCapacity `yaml:"capacity" json:"capacity"` // 容量限制 TODO 暂时不实现
}

type CachePolicyStorageType = string

type CommonScript struct {
	Id       int64  `yaml:"id" json:"id"`
	IsOn     bool   `yaml:"isOn" json:"isOn"`
	Filename string `yaml:"filename" json:"filename"`
	Code     string `yaml:"code" json:"code"`
}

type ConfigCode = string

type DomainMismatchAction struct {
	Code    string   `yaml:"code" json:"code"`       // 动作代号
	Options maps.Map `yaml:"options" json:"options"` // 动作选项
}

type DomainMismatchCloseOptions struct {
}

type DomainMismatchPageOptions struct {
	StatusCode  int    `yaml:"statusCode" json:"statusCode"`
	ContentHTML string `yaml:"contentHTML" json:"contentHTML"`
}

type DomainMismatchRedirectOptions struct {
	URL string `yaml:"url" json:"url"`
}

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

type FTPServerRef struct {
	IsOn        bool  `yaml:"isOn" json:"isOn"`
	FTPServerId int64 `yaml:"ftpServerId" json:"ftpServerId"`
}

type FollowProtocolConfig struct {
	IsPrior bool `yaml:"isPrior" json:"isPrior"` // 是否覆盖父级配置
	IsOn    bool `yaml:"isOn" json:"isOn"`       // 是否启用
	HTTP    struct {
		Port       int  `yaml:"port" json:"port"`             // 端口
		FollowPort bool `yaml:"followPort" json:"followPort"` // 跟随端口
	} `yaml:"http" json:"http"` // HTTP配置
	HTTPS struct {
		Port       int  `yaml:"port" json:"port"`             // 端口
		FollowPort bool `yaml:"followPort" json:"followPort"` // 跟随端口
	} `yaml:"https" json:"https"` // HTTPS配置
}

type GlobalServerConfig struct {
	HTTPAll struct {
		MatchDomainStrictly  bool                  `yaml:"matchDomainStrictly" json:"matchDomainStrictly"`   // 是否严格匹配域名
		AllowMismatchDomains []string              `yaml:"allowMismatchDomains" json:"allowMismatchDomains"` // 允许的不匹配的域名
		AllowNodeIP          bool                  `yaml:"allowNodeIP" json:"allowNodeIP"`                   // 允许IP直接访问
		NodeIPShowPage       bool                  `yaml:"nodeIPShowPage" json:"nodeIPShowPage"`             // 访问IP地址是否显示页面
		NodeIPPageHTML       string                `yaml:"nodeIPPageHTML" json:"nodeIPPageHTML"`             // 访问IP地址页面内容
		DefaultDomain        string                `yaml:"defaultDomain" json:"defaultDomain"`               // 默认的域名
		DomainMismatchAction *DomainMismatchAction `yaml:"domainMismatchAction" json:"domainMismatchAction"` // 不匹配时采取的动作

		SupportsLowVersionHTTP    bool                      `yaml:"supportsLowVersionHTTP" json:"supportsLowVersionHTTP"`       // 是否启用低版本HTTP
		MatchCertFromAllServers   bool                      `yaml:"matchCertFromAllServers" json:"matchCertFromAllServers"`     // 从所有服务中匹配证书（不要轻易开启！）
		ForceLnRequest            bool                      `yaml:"forceLnRequest" json:"forceLnRequest"`                       // 强制从Ln请求内容
		LnRequestSchedulingMethod LnRequestSchedulingMethod `yaml:"lnRequestSchedulingMethod" json:"lnRequestSchedulingMethod"` // Ln请求调度方法
		ServerName                string                    `yaml:"serverName" json:"serverName"`                               // Server名称
		EnableServerAddrVariable  bool                      `yaml:"enableServerAddrVariable" json:"enableServerAddrVariable"`   // 是否支持${serverAddr}变量

		DomainAuditingIsOn   bool   `yaml:"domainAuditingIsOn" json:"domainAuditingIsOn"`     // 域名是否需要审核
		DomainAuditingPrompt string `yaml:"domainAuditingPrompt" json:"domainAuditingPrompt"` // 域名审核的提示

		RequestOriginsWithEncodings bool `yaml:"requestOriginsWithEncodings" json:"requestOriginsWithEncodings"` // 使用使用压缩编码回源
	} `yaml:"httpAll" json:"httpAll"` // HTTP统一配置

	TCPAll struct {
		PortRangeMin int   `yaml:"portRangeMin" json:"portRangeMin"` // 最小端口
		PortRangeMax int   `yaml:"portRangeMax" json:"portRangeMax"` // 最大端口
		DenyPorts    []int `yaml:"denyPorts" json:"denyPorts"`       // 禁止使用的端口
	} `yaml:"tcpAll" json:"tcpAll"`

	HTTPAccessLog struct {
		IsOn                     bool `yaml:"isOn" json:"isOn"`                                         // 是否启用此功能
		EnableRequestHeaders     bool `yaml:"enableRequestHeaders" json:"enableRequestHeaders"`         // 记录请求Header
		CommonRequestHeadersOnly bool `yaml:"commonRequestHeadersOnly" json:"commonRequestHeadersOnly"` // 只保留通用Header
		EnableResponseHeaders    bool `yaml:"enableResponseHeaders" json:"enableResponseHeaders"`       // 记录响应Header
		EnableCookies            bool `yaml:"enableCookies" json:"enableCookies"`                       // 记录Cookie
		EnableServerNotFound     bool `yaml:"enableServerNotFound" json:"enableServerNotFound"`         // 记录服务找不到的日志
	} `yaml:"httpAccessLog" json:"httpAccessLog"` // 访问日志配置

	Stat struct {
		Upload struct {
			MaxCities    int16 `yaml:"maxCities" json:"maxCities"`       // 最大区域数量
			MaxProviders int16 `yaml:"maxProviders" json:"maxProviders"` // 最大运营商数量
			MaxSystems   int16 `yaml:"maxSystems" json:"maxSystems"`     // 最大操作系统数量
			MaxBrowsers  int16 `yaml:"maxBrowsers" json:"maxBrowsers"`   // 最大浏览器数量
		} `yaml:"upload" json:"upload"` // 上传相关设置
	} `yaml:"stat" json:"stat"` // 统计相关配置

	Performance struct {
		Debug            bool `yaml:"debug" json:"debug"`                       // Debug模式
		AutoWriteTimeout bool `yaml:"autoWriteTimeout" json:"autoWriteTimeout"` // 是否自动写超时
		AutoReadTimeout  bool `yaml:"autoReadTimeout" json:"autoReadTimeout"`   // 是否自动读超时
	} `yaml:"performance" json:"performance"` // 性能

	Log struct {
		RecordServerError bool `yaml:"recordServerError" json:"recordServerError"` // 记录服务错误到运行日志
	} `yaml:"log" json:"log"` // 运行日志配置
}

type HLSConfig struct {
	IsPrior    bool                 `yaml:"isPrior" json:"isPrior"`
	Encrypting *HLSEncryptingConfig `yaml:"encrypting" json:"encrypting"` // 加密设置
}

type HLSEncryptingConfig struct {
	IsOn bool `yaml:"isOn" json:"isOn"` // 是否启用

	OnlyURLPatterns   []*shared.URLPattern `yaml:"onlyURLPatterns" json:"onlyURLPatterns"`     // 仅限的URL
	ExceptURLPatterns []*shared.URLPattern `yaml:"exceptURLPatterns" json:"exceptURLPatterns"` // 排除的URL
}

type HTTPAccessLogField = int

type HTTPAccessLogRef struct {
	IsPrior bool `yaml:"isPrior" json:"isPrior"` // 是否覆盖
	IsOn    bool `yaml:"isOn" json:"isOn"`       // 是否启用

	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

	EnableClientClosed bool `yaml:"enableClientClosed" json:"enableClientClosed"` // 是否记录客户端关闭事件

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

	FirewallOnly bool `yaml:"firewallOnly" json:"firewallOnly"` // 是否只记录防火墙相关日志
}

type HTTPAuthBaseMethod struct {
	Exts    []string `json:"exts"`
	Domains []string `json:"domains"`
}

type HTTPAuthBasicMethod struct {
	HTTPAuthBaseMethod

	Users   []*HTTPAuthBasicMethodUser `json:"users"`
	Realm   string                     `json:"realm"`
	Charset string                     `json:"charset"`
	// contains filtered or unexported fields
}

type HTTPAuthBasicMethodUser struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

type HTTPAuthConfig struct {
	IsPrior    bool                 `yaml:"isPrior" json:"isPrior"`
	IsOn       bool                 `yaml:"isOn" json:"isOn"`
	PolicyRefs []*HTTPAuthPolicyRef `yaml:"policyRefs" json:"policyRefs"`
}

type HTTPAuthMethodInterface interface {
	// Init 初始化
	Init(params map[string]any) error

	// MatchRequest 是否匹配请求
	MatchRequest(req *http.Request) bool

	// Filter 过滤
	Filter(req *http.Request, subReqFunc func(subReq *http.Request) (status int, err error), formatter func(string) string) (ok bool, newURI string, uriChanged bool, err error)

	// SetExts 设置扩展名
	SetExts(exts []string)

	// SetDomains 设置域名
	SetDomains(domains []string)
}

type HTTPAuthPolicy struct {
	Id     int64                  `json:"id"`
	Name   string                 `json:"name"`
	IsOn   bool                   `json:"isOn"`
	Type   HTTPAuthType           `json:"type"`
	Params map[string]interface{} `json:"params"`
	// contains filtered or unexported fields
}

type HTTPAuthPolicyRef struct {
	IsOn         bool            `yaml:"isOn" json:"isOn"`
	AuthPolicyId int64           `yaml:"authPolicyId" json:"authPolicyId"`
	AuthPolicy   *HTTPAuthPolicy `yaml:"authPolicy" json:"authPolicy"`
}

type HTTPAuthSubRequestMethod struct {
	HTTPAuthBaseMethod

	URL    string `json:"url"`
	Method string `json:"method"`
	// contains filtered or unexported fields
}

type HTTPAuthType = string

type HTTPAuthTypeDefinition struct {
	Name        string `json:"name"`
	Code        string `json:"code"`
	Description string `json:"description"`
}

type HTTPBaseOptimizationConfig struct {
	OnlyURLPatterns   []*shared.URLPattern `yaml:"onlyURLPatterns" json:"onlyURLPatterns"`     // 仅限的URL
	ExceptURLPatterns []*shared.URLPattern `yaml:"exceptURLPatterns" json:"exceptURLPatterns"` // 排除的URL
}

type HTTPBrotliCompressionConfig struct {
	Id   int64 `yaml:"id" json:"id"` // ID
	IsOn bool  `yaml:"isOn" json:"isOn"`

	Level     int8                           `yaml:"level" json:"level"`         // 级别
	MinLength *shared.SizeCapacity           `yaml:"minLength" json:"minLength"` // 最小压缩对象比如4m, 24k
	MaxLength *shared.SizeCapacity           `yaml:"maxLength" json:"maxLength"` // 最大压缩对象
	Conds     *shared.HTTPRequestCondsConfig `yaml:"conds" json:"conds"`         // 匹配条件
	// contains filtered or unexported fields
}

type HTTPCCConfig struct {
	IsPrior    bool               `yaml:"isPrior" json:"isPrior"`       // 是否覆盖父级
	IsOn       bool               `yaml:"isOn" json:"isOn"`             // 是否启用
	Thresholds []*HTTPCCThreshold `yaml:"thresholds" json:"thresholds"` // 阈值设置
}

type HTTPCCThreshold struct {
}

type HTTPCSSOptimizationConfig struct {
	HTTPBaseOptimizationConfig

	IsOn bool `yaml:"isOn" json:"isOn"`

	Precision int  `yaml:"precision" json:"precision"`
	KeepCSS2  bool `yaml:"keepCSS2" json:"keepCSS2"`
}

type HTTPCacheConfig struct {
	IsPrior bool `yaml:"isPrior" json:"isPrior"`
	IsOn    bool `yaml:"isOn" json:"isOn"`

	AddStatusHeader          bool `yaml:"addStatusHeader" json:"addStatusHeader"`                   // 是否增加命中状态Header（X-Cache）
	AddAgeHeader             bool `yaml:"addAgeHeader" json:"addAgeHeader"`                         // 是否增加Age Header
	EnableCacheControlMaxAge bool `yaml:"enableCacheControlMaxAge" json:"enableCacheControlMaxAge"` // 是否支持Cache-Control: max-age=...
	DisablePolicyRefs        bool `yaml:"disablePolicyRefs" json:"disablePolicyRefs"`               // 是否停用策略中定义的条件

	Key *HTTPCacheKeyConfig `yaml:"key" json:"key"` // 键值全局配置

	PurgeIsOn bool   `yaml:"purgeIsOn" json:"purgeIsOn"` // 是否允许使用Purge方法清理
	PurgeKey  string `yaml:"purgeKey" json:"purgeKey"`   // Purge时使用的X-Edge-Purge-Key

	Stale *HTTPCacheStaleConfig `yaml:"stale" json:"stale"` // 陈旧缓存使用策略

	CacheRefs []*HTTPCacheRef `yaml:"cacheRefs" json:"cacheRefs"` // 缓存条件配置
}

type HTTPCacheKeyConfig struct {
	IsOn   bool   `yaml:"isOn" json:"isOn"`
	Scheme string `yaml:"scheme" json:"scheme"`
	Host   string `yaml:"host" json:"host"`
}

type HTTPCachePolicy struct {
	Id                   int64                  `yaml:"id" json:"id"`
	IsOn                 bool                   `yaml:"isOn" json:"isOn"`                                 // 是否开启
	Name                 string                 `yaml:"name" json:"name"`                                 // 名称
	Description          string                 `yaml:"description" json:"description"`                   // 描述
	Capacity             *shared.SizeCapacity   `yaml:"capacity" json:"capacity"`                         // 最大内容容量
	MaxSize              *shared.SizeCapacity   `yaml:"maxSize" json:"maxSize"`                           // 单个缓存最大尺寸
	Type                 CachePolicyStorageType `yaml:"type" json:"type"`                                 // 类型
	Options              map[string]any         `yaml:"options" json:"options"`                           // 选项
	Life                 *shared.TimeDuration   `yaml:"life" json:"life"`                                 // 默认有效期 TODO 需要实现
	MinLife              *shared.TimeDuration   `yaml:"minLife" json:"minLife"`                           // 最小有效期 TODO 需要实现
	MaxLife              *shared.TimeDuration   `yaml:"maxLife" json:"maxLife"`                           // 最大有效期 TODO 需要实现
	SyncCompressionCache bool                   `yaml:"syncCompressionCache" json:"syncCompressionCache"` // 同步写入压缩缓存
	FetchTimeout         *shared.TimeDuration   `yaml:"fetchTimeout" json:"fetchTimeout"`                 // 预热超时时间

	CacheRefs []*HTTPCacheRef `yaml:"cacheRefs" json:"cacheRefs"` // 缓存配置

	PersistenceAutoPurgeCount    int     `yaml:"persistenceAutoPurgeCount" json:"persistenceAutoPurgeCount"`       // 每次自动清理的条数 TODO 需要实现
	PersistenceAutoPurgeInterval int     `yaml:"persistenceAutoPurgeInterval" json:"persistenceAutoPurgeInterval"` // 自动清理的时间间隔（秒） TODO 需要实现
	PersistenceLFUFreePercent    float32 `yaml:"persistenceLFUFreePercent" json:"persistenceLFUFreePercent"`       // LFU算法执行阈值，剩余空间比例，使用百分比，比如20 TODO 需要实现
	PersistenceHitSampleRate     int     `yaml:"persistenceHitSampleRate" json:"persistenceHitSampleRate"`         // 热点数据采样比例 TODO 需要实现

	MemoryAutoPurgeCount     int     `yaml:"memoryAutoPurgeCount" json:"memoryAutoPurgeCount"`         // 每次自动清理的条数 TODO 需要实现
	MemoryAutoPurgeInterval  int     `yaml:"memoryAutoPurgeInterval" json:"memoryAutoPurgeInterval"`   // 自动清理的时间间隔（秒） TODO 需要实现
	MemoryLFUFreePercent     float32 `yaml:"memoryLFUFreePercent" json:"memoryLFUFreePercent"`         // LFU算法执行阈值，剩余空间比例，使用百分比，比如20 TODO 需要实现
	MemoryAutoFlushQueueSize int     `yaml:"memoryAutoFlushQueueSize" json:"memoryAutoFlushQueueSize"` // 自动刷新到持久层队列尺寸 TODO 需要实现
	// contains filtered or unexported fields
}

type HTTPCacheRef struct {
	IsOn          bool  `yaml:"isOn" json:"isOn"`
	CachePolicyId int64 `yaml:"cachePolicyId" json:"cachePolicyId"`

	Key         string                 `yaml:"key" json:"key"`                 // 每个缓存的Key规则，里面可以有变量
	Life        *shared.TimeDuration   `yaml:"life" json:"life"`               // 时间
	ExpiresTime *HTTPExpiresTimeConfig `yaml:"expiresTime" json:"expiresTime"` // 客户端过期时间
	Status      []int                  `yaml:"status" json:"status"`           // 缓存的状态码列表
	MinSize     *shared.SizeCapacity   `yaml:"minSize" json:"minSize"`         // 能够缓存的最小尺寸
	MaxSize     *shared.SizeCapacity   `yaml:"maxSize" json:"maxSize"`         // 能够缓存的最大尺寸
	Methods     []string               `yaml:"methods" json:"methods"`         // 支持的请求方法

	SkipResponseCacheControlValues []string `yaml:"skipCacheControlValues" json:"skipCacheControlValues"`       // 可以跳过的响应的Cache-Control值
	SkipResponseSetCookie          bool     `yaml:"skipSetCookie" json:"skipSetCookie"`                         // 是否跳过响应的Set-Cookie Header
	EnableRequestCachePragma       bool     `yaml:"enableRequestCachePragma" json:"enableRequestCachePragma"`   // 是否支持客户端的Pragma: no-cache
	AllowChunkedEncoding           bool     `yaml:"allowChunkedEncoding" json:"allowChunkedEncoding"`           // 是否允许分片内容
	AllowPartialContent            bool     `yaml:"allowPartialContent" json:"allowPartialContent"`             // 支持分段内容缓存
	ForcePartialContent            bool     `yaml:"forcePartialContent" json:"forcePartialContent"`             // 强制分段内容优先
	AlwaysForwardRangeRequest      bool     `yaml:"alwaysForwardRangeRequest" json:"alwaysForwardRangeRequest"` // 强制Range请求回源
	EnableIfNoneMatch              bool     `yaml:"enableIfNoneMatch" json:"enableIfNoneMatch"`                 // 支持If-None-match
	EnableIfModifiedSince          bool     `yaml:"enableIfModifiedSince" json:"enableIfModifiedSince"`         // 支持If-Modified-Since
	EnableReadingOriginAsync       bool     `yaml:"enableReadingOriginAsync" json:"enableReadingOriginAsync"`   // 允许异步读取源站

	Conds      *shared.HTTPRequestCondsConfig `yaml:"conds" json:"conds"`           // 复杂请求条件组合
	SimpleCond *shared.HTTPRequestCond        `yaml:"simpleCond" json:"simpleCond"` // 简单条件

	CachePolicy *HTTPCachePolicy `yaml:"cachePolicy" json:"cachePolicy"`

	IsReverse bool `yaml:"isReverse" json:"isReverse"` // 是否为反向条件，反向条件的不缓存
	// contains filtered or unexported fields
}

type HTTPCacheStaleConfig struct {
	IsPrior bool `yaml:"isPrior" json:"isPrior"`
	IsOn    bool `yaml:"isOn" json:"isOn"` // 是否启用

	Status                    []int                `yaml:"status" json:"status"`                                       // 状态列表
	SupportStaleIfErrorHeader bool                 `yaml:"supportStaleIfErrorHeader" json:"supportStaleIfErrorHeader"` // 是否支持stale-if-error
	Life                      *shared.TimeDuration `yaml:"life" json:"life"`                                           // 陈旧内容生命周期
}

type HTTPCharsetConfig struct {
	IsPrior bool   `yaml:"isPrior" json:"isPrior"` // 是否覆盖
	IsOn    bool   `yaml:"isOn" json:"isOn"`       // 是否启用
	Charset string `yaml:"charset" json:"charset"` // 字符集
	IsUpper bool   `yaml:"isUpper" json:"isUpper"` // 是否要大写
	Force   bool   `yaml:"force" json:"force"`     // 是否强制覆盖

}

type HTTPCompressionConfig struct {
	IsPrior bool `yaml:"isPrior" json:"isPrior"`
	IsOn    bool `yaml:"isOn" json:"isOn"`

	UseDefaultTypes bool                  `yaml:"useDefaultTypes" json:"useDefaultTypes"` // 是否使用默认的类型
	Types           []HTTPCompressionType `yaml:"types" json:"types"`                     // 支持的类型，如果为空表示默认顺序
	Level           int8                  `yaml:"level" json:"level"`                     // 级别：1-12
	DecompressData  bool                  `yaml:"decompressData" json:"decompressData"`   // 是否解压已压缩内容

	GzipRef    *HTTPCompressionRef `yaml:"gzipRef" json:"gzipRef"`
	DeflateRef *HTTPCompressionRef `yaml:"deflateRef" json:"deflateRef"`
	BrotliRef  *HTTPCompressionRef `yaml:"brotliRef" json:"brotliRef"`

	Gzip    *HTTPGzipCompressionConfig    `yaml:"gzip" json:"gzip"`
	Deflate *HTTPDeflateCompressionConfig `yaml:"deflate" json:"deflate"`
	Brotli  *HTTPBrotliCompressionConfig  `yaml:"brotli" json:"brotli"`

	MinLength            *shared.SizeCapacity           `yaml:"minLength" json:"minLength"`                       // 最小压缩对象比如4m, 24k
	MaxLength            *shared.SizeCapacity           `yaml:"maxLength" json:"maxLength"`                       // 最大压缩对象
	MimeTypes            []string                       `yaml:"mimeTypes" json:"mimeTypes"`                       // 支持的MimeType，支持image/*这样的通配符使用
	Extensions           []string                       `yaml:"extensions" json:"extensions"`                     // 文件扩展名，包含点符号，不区分大小写
	ExceptExtensions     []string                       `yaml:"exceptExtensions" json:"exceptExtensions"`         // 例外扩展名
	Conds                *shared.HTTPRequestCondsConfig `yaml:"conds" json:"conds"`                               // 匹配条件
	EnablePartialContent bool                           `yaml:"enablePartialContent" json:"enablePartialContent"` // 支持PartialContent压缩

	OnlyURLPatterns   []*shared.URLPattern `yaml:"onlyURLPatterns" json:"onlyURLPatterns"`     // 仅限的URL
	ExceptURLPatterns []*shared.URLPattern `yaml:"exceptURLPatterns" json:"exceptURLPatterns"` // 排除的URL
	// contains filtered or unexported fields
}

type HTTPCompressionRef struct {
	Id   int64 `yaml:"id" json:"id"`
	IsOn bool  `yaml:"isOn" json:"isOn"`
}

type HTTPCompressionType = string

type HTTPDeflateCompressionConfig struct {
	Id   int64 `yaml:"id" json:"id"` // ID
	IsOn bool  `yaml:"isOn" json:"isOn"`

	Level     int8                           `yaml:"level" json:"level"`         // 级别
	MinLength *shared.SizeCapacity           `yaml:"minLength" json:"minLength"` // 最小压缩对象比如4m, 24k
	MaxLength *shared.SizeCapacity           `yaml:"maxLength" json:"maxLength"` // 最大压缩对象
	Conds     *shared.HTTPRequestCondsConfig `yaml:"conds" json:"conds"`         // 匹配条件
	// contains filtered or unexported fields
}

type HTTPExpiresTimeConfig struct {
	IsPrior       bool                 `yaml:"isPrior" json:"isPrior"`             // 是否覆盖父级设置
	IsOn          bool                 `yaml:"isOn" json:"isOn"`                   // 是否启用
	Overwrite     bool                 `yaml:"overwrite" json:"overwrite"`         // 是否覆盖
	AutoCalculate bool                 `yaml:"autoCalculate" json:"autoCalculate"` // 是否自动计算
	Duration      *shared.TimeDuration `yaml:"duration" json:"duration"`           // 周期
}

type HTTPFastcgiConfig struct {
	Id   int64 `yaml:"id" json:"id"`
	IsOn bool  `yaml:"isOn" json:"isOn"`

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

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

type HTTPFastcgiParam struct {
	Name  string `yaml:"name" json:"name"`
	Value string `yaml:"value" json:"value"`
}

type HTTPFastcgiRef struct {
	IsPrior    bool    `yaml:"isPrior" json:"isPrior"`       // 是否覆盖
	IsOn       bool    `yaml:"isOn" json:"isOn"`             // 是否开启
	FastcgiIds []int64 `yaml:"fastcgiIds" json:"fastcgiIds"` // Fastcgi ID列表
}

type HTTPFileCacheStorage struct {
	Dir          string               `yaml:"dir" json:"dir"`                   // 目录
	MinFreeSize  *shared.SizeCapacity `yaml:"minFreeSize" json:"minFreeSize"`   // 最小剩余空间
	SubDirs      []*CacheDir          `yaml:"cacheDir" json:"subDirs"`          // 子目录
	MemoryPolicy *HTTPCachePolicy     `yaml:"memoryPolicy" json:"memoryPolicy"` // 内存二级缓存

	OpenFileCache  *OpenFileCacheConfig `yaml:"openFileCache" json:"openFileCache"`   // open file cache配置
	EnableSendfile bool                 `yaml:"enableSendFile" json:"enableSendfile"` // 是否启用Sendfile

	EnableMMAP bool `yaml:"enableMMAP" json:"enableMMAP"` // 是否启用MMAP
}

type HTTPFilterPolicy struct {
}

type HTTPFilterRef struct {
	IsPrior        bool  `yaml:"isPrior" json:"isPrior"`
	IsOn           bool  `yaml:"isOn" json:"isOn"`
	FilterPolicyId int64 `yaml:"filterPolicyId" json:"filterPolicyId"`
}

type HTTPGzipCompressionConfig struct {
	Id        int64                          `yaml:"id" json:"id"`               // ID
	IsOn      bool                           `yaml:"isOn" json:"isOn"`           // 是否启用
	Level     int8                           `yaml:"level" json:"level"`         // 1-9
	MinLength *shared.SizeCapacity           `yaml:"minLength" json:"minLength"` // 最小压缩对象比如4m, 24k
	MaxLength *shared.SizeCapacity           `yaml:"maxLength" json:"maxLength"` // 最大压缩对象
	Conds     *shared.HTTPRequestCondsConfig `yaml:"conds" json:"conds"`         // 匹配条件
	// contains filtered or unexported fields
}

type HTTPGzipRef struct {
	IsPrior bool  `yaml:"isPrior" json:"isPrior"` // 是否覆盖
	IsOn    bool  `yaml:"isOn" json:"isOn"`       // 是否开启
	GzipId  int64 `yaml:"gzipId" json:"gzipId"`   // 使用的配置ID
}

type HTTPHTMLOptimizationConfig struct {
	HTTPBaseOptimizationConfig

	IsOn bool `yaml:"isOn" json:"isOn"`

	KeepComments            bool `yaml:"keepComments" json:"keepComments"`
	KeepConditionalComments bool `yaml:"keepConditionalComments" json:"keepConditionalComments"`
	KeepDefaultAttrVals     bool `yaml:"keepDefaultAttrVals" json:"keepDefaultAttrVals"`
	KeepDocumentTags        bool `yaml:"keepDocumentTags" json:"keepDocumentTags"`
	KeepEndTags             bool `yaml:"keepEndTags" json:"keepEndTags"`
	KeepQuotes              bool `yaml:"keepQuotes" json:"keepQuotes"`
	KeepWhitespace          bool `yaml:"keepWhitespace" json:"keepWhitespace"`
}

type HTTPHostRedirectConfig struct {
	IsOn   bool `yaml:"isOn" json:"isOn"`     // 是否开启
	Status int  `yaml:"status" json:"status"` // 跳转用的状态码

	Type string               `yaml:"type" json:"type"` // 类型
	Mode HTTPHostRedirectType `yaml:"mode" json:"mode"` // 模式

	// URL跳转
	BeforeURL string `yaml:"beforeURL" json:"beforeURL"` // 跳转前的地址
	AfterURL  string `yaml:"afterURL" json:"afterURL"`   // 跳转后的地址

	MatchPrefix bool `yaml:"matchPrefix" json:"matchPrefix"` // 只匹配前缀部分
	MatchRegexp bool `yaml:"matchRegexp" json:"matchRegexp"` // 匹配正则表达式

	KeepRequestURI bool                           `yaml:"keepRequestURI" json:"keepRequestURI"` // 保留请求URI
	KeepArgs       bool                           `yaml:"keepArgs" json:"keepArgs"`             // 保留参数
	Conds          *shared.HTTPRequestCondsConfig `yaml:"conds" json:"conds"`                   // 匹配条件

	// 域名跳转
	DomainsAll              bool     `yaml:"domainAll" json:"domainsAll"`                            // 所有域名都跳转
	DomainsBefore           []string `yaml:"domainsBefore" json:"domainsBefore"`                     // 指定跳转之前的域名
	DomainBeforeIgnorePorts bool     `yaml:"domainBeforeIgnorePorts" json:"domainBeforeIgnorePorts"` // 忽略跳转前端口
	DomainAfter             string   `yaml:"domainAfter" json:"domainAfter"`                         // 跳转之后的域名
	DomainAfterScheme       string   `yaml:"domainAfterScheme" json:"domainAfterScheme"`             // 跳转之后的协议

	// 端口跳转
	PortsAll        bool     `yaml:"portsAll" json:"portsAll"`               // 所有端口
	PortsBefore     []string `yaml:"portsBefore" json:"portsBefore"`         // 跳转之前的端口：8080, 8080-8090
	PortAfter       int      `yaml:"port" json:"portAfter"`                  // 跳转之后的端口
	PortAfterScheme string   `yaml:"portAfterScheme" json:"portAfterScheme"` // 跳转之后的协议

	OnlyDomains   []string `yaml:"onlyDomains" json:"onlyDomains"`     // 限制域名
	ExceptDomains []string `yaml:"exceptDomains" json:"exceptDomains"` // 排除域名
	// contains filtered or unexported fields
}

type HTTPHostRedirectType = string

type HTTPJavascriptOptimizationConfig struct {
	HTTPBaseOptimizationConfig

	IsOn bool `yaml:"isOn" json:"isOn"`

	Precision    int  `yaml:"precision" json:"precision"`
	Version      int  `yaml:"version" json:"version"`
	KeepVarNames bool `yaml:"keepVarNames" json:"keepVarNames"`
}

type HTTPLocationConfig struct {
	Id              int64                          `yaml:"id" json:"id"`                           // ID
	IsOn            bool                           `yaml:"isOn" json:"isOn"`                       // 是否启用
	Pattern         string                         `yaml:"pattern" json:"pattern"`                 // 匹配规则 TODO 未来支持更多样的匹配规则
	Name            string                         `yaml:"name" json:"name"`                       // 名称
	Web             *HTTPWebConfig                 `yaml:"web" json:"web"`                         // Web配置
	URLPrefix       string                         `yaml:"urlPrefix" json:"urlPrefix"`             // 实际的URL前缀，TODO 未来支持变量
	Description     string                         `yaml:"description" json:"description"`         // 描述
	ReverseProxyRef *ReverseProxyRef               `yaml:"reverseProxyRef" json:"reverseProxyRef"` // 反向代理引用
	ReverseProxy    *ReverseProxyConfig            `yaml:"reverseProxy" json:"reverseProxy"`       // 反向代理设置
	IsBreak         bool                           `yaml:"isBreak" json:"isBreak"`                 // 终止向下解析
	Children        []*HTTPLocationConfig          `yaml:"children" json:"children"`               // 子规则
	Conds           *shared.HTTPRequestCondsConfig `yaml:"conds" json:"conds"`                     // 匹配条件
	Domains         []string                       `yaml:"domains" json:"domains"`                 // 所属域名
	// contains filtered or unexported fields
}

type HTTPLocationPatternType = int

type HTTPLocationRef struct {
	IsOn       bool               `yaml:"isOn" json:"isOn"`             // 是否启用
	LocationId int64              `yaml:"locationId" json:"locationId"` // 路径ID
	Children   []*HTTPLocationRef `yaml:"children" json:"children"`     // 子路径规则
}

type HTTPMemoryCacheStorage struct {
}

type HTTPPageBodyType = string

type HTTPPageConfig struct {
	Id        int64    `yaml:"id" json:"id"`               // 页面ID
	IsOn      bool     `yaml:"isOn" json:"isOn"`           // 是否开启 TODO
	Status    []string `yaml:"status" json:"status"`       // 响应支持40x, 50x, 3x2
	NewStatus int      `yaml:"newStatus" json:"newStatus"` // 新状态码

	BodyType HTTPPageBodyType `yaml:"bodyType" json:"bodyType"` // 内容类型
	URL      string           `yaml:"url" json:"url"`           // URL
	Body     string           `yaml:"body" json:"body"`         // 输出的内容

	OnlyURLPatterns   []*shared.URLPattern `yaml:"onlyURLPatterns" json:"onlyURLPatterns"`     // 仅限的URL
	ExceptURLPatterns []*shared.URLPattern `yaml:"exceptURLPatterns" json:"exceptURLPatterns"` // 排除的URL
	// contains filtered or unexported fields
}

type HTTPPageMinifier interface {
	Bytes(mediaType string, data []byte) ([]byte, error)
}

type HTTPPageOptimizationConfig struct {
	IsPrior bool `yaml:"isPrior" json:"isPrior"`

	HTML       *HTTPHTMLOptimizationConfig       `yaml:"html" json:"html"`
	Javascript *HTTPJavascriptOptimizationConfig `yaml:"javascript" json:"javascript"`
	CSS        *HTTPCSSOptimizationConfig        `yaml:"css" json:"css"`
	// contains filtered or unexported fields
}

type HTTPPageOptimizationMimeType = string

type HTTPProtocolConfig struct {
	BaseProtocol `yaml:",inline"`
}

type HTTPRedirectToHTTPSConfig struct {
	IsPrior bool   `yaml:"isPrior" json:"isPrior"` // 是否覆盖
	IsOn    bool   `yaml:"isOn" json:"isOn"`       // 是否开启
	Status  int    `yaml:"status" json:"status"`   // 跳转用的状态码
	Host    string `yaml:"host" json:"host"`       // 跳转后的Host
	Port    int    `yaml:"port" json:"port"`       // 跳转后的端口

	OnlyDomains   []string `yaml:"onlyDomains" json:"onlyDomains"`     // 允许的域名
	ExceptDomains []string `yaml:"exceptDomains" json:"exceptDomains"` // 排除的域名
}

type HTTPRemoteAddrConfig struct {
	IsPrior bool               `yaml:"isPrior" json:"isPrior"`
	IsOn    bool               `yaml:"isOn" json:"isOn"`
	Value   string             `yaml:"value" json:"value"` // 值变量
	Type    HTTPRemoteAddrType `yaml:"type" json:"type"`   // 类型

	RequestHeaderName string `yaml:"requestHeaderName" json:"requestHeaderName"` // 请求报头名称（type = requestHeader时生效）
	// contains filtered or unexported fields
}

type HTTPRemoteAddrType = string

type HTTPRequestLimitConfig struct {
	IsPrior             bool                 `yaml:"isPrior" json:"isPrior"`                         // 是否覆盖父级
	IsOn                bool                 `yaml:"isOn" json:"isOn"`                               // 是否启用
	MaxConns            int                  `yaml:"maxConns" json:"maxConns"`                       // 并发连接数
	MaxConnsPerIP       int                  `yaml:"maxConnsPerIP" json:"maxConnsPerIP"`             // 单个IP并发连接数
	OutBandwidthPerConn *shared.SizeCapacity `yaml:"outBandwidthPerConn" json:"outBandwidthPerConn"` // 下行流量限制
	MaxBodySize         *shared.SizeCapacity `yaml:"maxBodySize" json:"maxBodySize"`                 // 单个请求最大尺寸
	// contains filtered or unexported fields
}

type HTTPRequestScriptsConfig struct {
	InitGroup    *ScriptGroupConfig `yaml:"initGroup" json:"initGroup"`
	RequestGroup *ScriptGroupConfig `yaml:"requestGroup" json:"requestGroup"`
}

type HTTPRewriteMode = string

type HTTPRewriteRef struct {
	IsOn          bool  `yaml:"isOn" json:"isOn"`                   // 是否启用
	RewriteRuleId int64 `yaml:"rewriteRuleId" json:"rewriteRuleId"` // 规则ID
}

type HTTPRewriteRule struct {
	Id   int64 `yaml:"id" json:"id"`     // ID
	IsOn bool  `yaml:"isOn" json:"isOn"` // 是否开启

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

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

	// 模式
	Mode           HTTPRewriteMode `yaml:"mode" json:"mode"`
	RedirectStatus int             `yaml:"redirectStatus" json:"redirectStatus"` // 跳转的状态码
	ProxyHost      string          `yaml:"proxyHost" json:"proxyHost"`           // 代理模式下的Host

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

	// 其他选项
	IsBreak   bool `yaml:"isBreak" json:"isBreak"`     // 终止向下解析
	WithQuery bool `yaml:"withQuery" json:"withQuery"` // 是否保留QueryString
	// contains filtered or unexported fields
}

type HTTPRootConfig struct {
	IsPrior           bool                 `yaml:"isPrior" json:"isPrior"`                     // 是否优先
	IsOn              bool                 `yaml:"isOn" json:"isOn"`                           // 是否启用
	Dir               string               `yaml:"dir" json:"dir"`                             // 目录
	Indexes           []string             `yaml:"indexes" json:"indexes"`                     // 默认首页文件
	StripPrefix       string               `yaml:"stripPrefix" json:"stripPrefix"`             // 去除URL前缀
	DecodePath        bool                 `yaml:"decodePath" json:"decodePath"`               // 是否对请求路径进行解码
	IsBreak           bool                 `yaml:"isBreak" json:"isBreak"`                     // 找不到文件的情况下是否终止
	ExceptHiddenFiles bool                 `yaml:"exceptHiddenFiles" json:"exceptHiddenFiles"` // 排除隐藏文件
	OnlyURLPatterns   []*shared.URLPattern `yaml:"onlyURLPatterns" json:"onlyURLPatterns"`     // 仅限的URL
	ExceptURLPatterns []*shared.URLPattern `yaml:"exceptURLPatterns" json:"exceptURLPatterns"` // 排除的URL
	// contains filtered or unexported fields
}

type HTTPSProtocolConfig struct {
	BaseProtocol `yaml:",inline"`

	SSLPolicyRef *sslconfigs.SSLPolicyRef `yaml:"sslPolicyRef" json:"sslPolicyRef"`
	SSLPolicy    *sslconfigs.SSLPolicy    `yaml:"sslPolicy" json:"sslPolicy"`
}

type HTTPShutdownConfig struct {
	IsPrior bool `yaml:"isPrior" json:"isPrior"`
	IsOn    bool `yaml:"isOn" json:"isOn"`

	BodyType HTTPPageBodyType `yaml:"bodyType" json:"bodyType"` // 内容类型
	URL      string           `yaml:"url" json:"url"`           // URL
	Body     string           `yaml:"body" json:"body"`         // 输出的内容

	Status int `yaml:"status" json:"status"`
}

type HTTPStatRef struct {
	IsPrior bool `yaml:"isPrior" json:"isPrior"` // 是否覆盖
	IsOn    bool `yaml:"isOn" json:"isOn"`       // 是否开启
}

type HTTPStatus struct {
	Code int    `json:"code"`
	Text string `json:"text"`
}

type HTTPWebConfig struct {
	Id                 int64                               `yaml:"id" json:"id"`                                 // ID
	IsOn               bool                                `yaml:"isOn" json:"isOn"`                             // 是否启用
	Locations          []*HTTPLocationConfig               `yaml:"locations" json:"locations"`                   // 路径规则 TODO
	LocationRefs       []*HTTPLocationRef                  `yaml:"locationRefs" json:"locationRefs"`             // 路径规则应用
	Compression        *HTTPCompressionConfig              `yaml:"compression" json:"compression"`               // 压缩配置
	Optimization       *HTTPPageOptimizationConfig         `yaml:"optimization" json:"optimization"`             // 页面优化配置
	WebP               *WebPImageConfig                    `yaml:"webp" json:"webp"`                             // WebP配置
	Charset            *HTTPCharsetConfig                  `yaml:"charset" json:"charset"`                       // 字符编码
	Shutdown           *HTTPShutdownConfig                 `yaml:"shutdown" json:"shutdown"`                     // 临时关闭配置
	Pages              []*HTTPPageConfig                   `yaml:"pages" json:"pages"`                           // 特殊页面配置
	RedirectToHttps    *HTTPRedirectToHTTPSConfig          `yaml:"redirectToHTTPS" json:"redirectToHTTPS"`       // 是否自动跳转到Https
	Root               *HTTPRootConfig                     `yaml:"root" json:"root"`                             // 资源根目录 TODO
	MaxRequestBodySize string                              `yaml:"maxRequestBodySize" json:"maxRequestBodySize"` // 请求body最大尺寸 TODO 需要实现
	AccessLogRef       *HTTPAccessLogRef                   `yaml:"accessLog" json:"accessLog"`                   // 访问日志配置
	StatRef            *HTTPStatRef                        `yaml:"statRef" json:"statRef"`                       // 统计配置
	Cache              *HTTPCacheConfig                    `yaml:"cache" json:"cache"`                           // 缓存配置
	FirewallRef        *firewallconfigs.HTTPFirewallRef    `yaml:"firewallRef" json:"firewallRef"`               // 防火墙设置
	FirewallPolicy     *firewallconfigs.HTTPFirewallPolicy `yaml:"firewallPolicy" json:"firewallPolicy"`         // 防火墙策略
	WebsocketRef       *HTTPWebsocketRef                   `yaml:"websocketRef" json:"websocketRef"`             // Websocket应用配置
	Websocket          *HTTPWebsocketConfig                `yaml:"websocket" json:"websocket"`                   // Websocket配置
	RewriteRefs        []*HTTPRewriteRef                   `yaml:"rewriteRefs" json:"rewriteRefs"`               // 重写规则配置
	RewriteRules       []*HTTPRewriteRule                  `yaml:"rewriteRules" json:"rewriteRules"`             // 重写规则
	FastcgiRef         *HTTPFastcgiRef                     `yaml:"fastcgiRef" json:"fastcgiRef"`                 // Fastcgi引用
	FastcgiList        []*HTTPFastcgiConfig                `yaml:"fastcgiList" json:"fastcgiList"`               // Fastcgi配置
	UserAgent          *UserAgentConfig                    `yaml:"userAgent" json:"userAgent"`                   // UserAgent配置
	HLS                *HLSConfig                          `yaml:"hls" json:"hls"`                               // HLS配置

	RequestHeaderPolicyRef  *shared.HTTPHeaderPolicyRef `yaml:"requestHeaderPolicyRef" json:"requestHeaderPolicyRef"`   // 请求Header
	RequestHeaderPolicy     *shared.HTTPHeaderPolicy    `yaml:"requestHeaderPolicy" json:"requestHeaderPolicy"`         // 请求Header策略
	ResponseHeaderPolicyRef *shared.HTTPHeaderPolicyRef `yaml:"responseHeaderPolicyRef" json:"responseHeaderPolicyRef"` // 响应Header`
	ResponseHeaderPolicy    *shared.HTTPHeaderPolicy    `yaml:"responseHeaderPolicy" json:"responseHeaderPolicy"`       // 响应Header策略

	FilterRefs     []*HTTPFilterRef    `yaml:"filterRefs" json:"filterRefs"`         // 筛选配置 TODO
	FilterPolicies []*HTTPFilterPolicy `yaml:"filterPolicies" json:"filterPolicies"` // 筛选策略

	HostRedirects []*HTTPHostRedirectConfig `yaml:"hostRedirects" json:"hostRedirects"` // 主机跳转
	Auth          *HTTPAuthConfig           `yaml:"auth" json:"auth"`                   // 认证配置
	Referers      *ReferersConfig           `yaml:"referers" json:"referers"`           // 防盗链设置

	RemoteAddr   *HTTPRemoteAddrConfig `yaml:"remoteAddr" json:"remoteAddr"`     // 客户端IP获取方式
	MergeSlashes bool                  `yaml:"mergeSlashes" json:"mergeSlashes"` // 是否合并路径中的斜杠（/）

	RequestLimit   *HTTPRequestLimitConfig   `yaml:"requestLimit" json:"requestLimit"`     // 并发请求限制
	RequestScripts *HTTPRequestScriptsConfig `yaml:"requestScripts" json:"requestScripts"` // HTTP请求相关脚本

	// UAM, CC ...
	UAM *UAMConfig    `yaml:"uam" json:"uam"`
	CC  *HTTPCCConfig `yaml:"cc" json:"cc"`
}

type HTTPWebsocketConfig struct {
	Id   int64 `yaml:"id" json:"id"`     // ID
	IsOn bool  `yaml:"isOn" json:"isOn"` // 是否开启

	// 握手超时时间
	HandshakeTimeout *shared.TimeDuration `yaml:"handshakeTimeout" json:"handshakeTimeout"`

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

	// 向后传递的来源
	RequestSameOrigin bool   `yaml:"requestSameOrigin" json:"requestSameOrigin"` // 和请求一致
	RequestOrigin     string `yaml:"requestOrigin" json:"requestOrigin"`         // 自行指定Origin，支持变量
	// contains filtered or unexported fields
}

type HTTPWebsocketRef struct {
	IsPrior     bool  `yaml:"isPrior" json:"isPrior"`
	IsOn        bool  `yaml:"isOn" json:"isOn"`
	WebsocketId int64 `yaml:"websocketId" json:"websocketId"`
}

type HealthCheckConfig struct {
	IsOn             bool                 `yaml:"isOn" json:"isOn"`                         // 是否开启
	URL              string               `yaml:"url" json:"url"`                           // 读取的URL
	Interval         *shared.TimeDuration `yaml:"interval" json:"interval"`                 // 检测周期
	StatusCodes      []int                `yaml:"statusCodes" json:"statusCodes"`           // 返回的状态码要求
	Timeout          *shared.TimeDuration `yaml:"timeout" json:"timeout"`                   // 超时时间
	CountTries       int64                `yaml:"countTries" json:"countTries"`             // 尝试次数
	TryDelay         *shared.TimeDuration `yaml:"tryDelay" json:"tryDelay"`                 // 尝试间隔
	FailActions      []maps.Map           `yaml:"failActions" json:"failActions"`           // 失败采取的动作 TODO
	RecoverActions   []maps.Map           `yaml:"recoverActions" json:"recoverActions"`     // 恢复采取的动作 TODO
	AutoDown         bool                 `yaml:"autoDown" json:"autoDown"`                 // 是否自动下线
	CountUp          int                  `yaml:"countUp" json:"countUp"`                   // 连续在线认定次数
	CountDown        int                  `yaml:"countDown" json:"countDown"`               // 连续离线认定次数
	UserAgent        string               `yaml:"userAgent" json:"userAgent"`               // 发起请求用的UserAgent
	OnlyBasicRequest bool                 `yaml:"onlyBasicRequest" json:"onlyBasicRequest"` // 只做基础的请求，不处理WAF、反向代理等
	AccessLogIsOn    bool                 `yaml:"accessLogIsOn" json:"accessLogIsOn"`       // 是否关闭访问日志
}

type IPLibraryType = string

type IPVersion = string

type LnRequestSchedulingMethod = string

type MetricChartType = string

type MetricItemCategory = string

type MetricItemConfig struct {
	Id            int64                `yaml:"id" json:"id"`
	IsOn          bool                 `yaml:"isOn" json:"isOn"`
	Category      MetricItemCategory   `yaml:"category" json:"category"`
	Period        int                  `yaml:"period" json:"period"`         // 统计周期
	PeriodUnit    MetricItemPeriodUnit `yaml:"periodUnit" json:"periodUnit"` // 统计周期单位
	Keys          []string             `yaml:"keys" json:"keys"`
	Value         string               `yaml:"value" json:"value"`
	Version       int32                `yaml:"version" json:"version"`
	ExpiresPeriod int                  `yaml:"expiresPeriod" json:"expiresPeriod"` // 过期周期
	// contains filtered or unexported fields
}

type MetricItemPeriodUnit = string

type MetricItemValueType = string

type MetricValueDefinition struct {
	Name        string `json:"name"`
	Code        string `json:"code"`
	Description string `json:"description"`
	Icon        string `json:"icon"`
	Type        string `json:"type"`
}

type NetworkAddressConfig struct {
	Protocol  Protocol `yaml:"protocol" json:"protocol"`   // 协议，http、tcp、tcp4、tcp6、unix、udp等
	Host      string   `yaml:"host" json:"host"`           // 主机地址或主机名，支持变量
	PortRange string   `yaml:"portRange" json:"portRange"` // 端口范围，支持 8080、8080-8090、8080:8090

	MinPort int `yaml:"minPort" json:"minPort"` // minPort和maxPort只是用来记录PortRange分解后的结果，不需要用户输入
	MaxPort int `yaml:"maxPort" json:"maxPort"`
	// contains filtered or unexported fields
}

type OpenFileCacheConfig struct {
	IsOn bool `yaml:"isOn" json:"isOn"`
	Max  int  `yaml:"max" json:"max"`
}

type OriginConfig struct {
	Id           int64                 `yaml:"id" json:"id"`                     // ID
	IsOn         bool                  `yaml:"isOn" json:"isOn"`                 // 是否启用
	Version      int                   `yaml:"version" json:"version"`           // 版本
	Name         string                `yaml:"name" json:"name"`                 // 名称
	Addr         *NetworkAddressConfig `yaml:"addr" json:"addr"`                 // 地址
	HTTP2Enabled bool                  `yaml:"http2Enabled" json:"http2Enabled"` // 是否支持HTTP2
	OSS          *ossconfigs.OSSConfig `yaml:"oss" json:"oss"`                   // 对象存储配置
	Description  string                `yaml:"description" json:"description"`   // 描述
	Code         string                `yaml:"code" json:"code"`                 // 代号

	Weight       uint                 `yaml:"weight" json:"weight"`           // 权重
	ConnTimeout  *shared.TimeDuration `yaml:"connTimeout" json:"connTimeout"` // 连接失败超时
	ReadTimeout  *shared.TimeDuration `yaml:"readTimeout" json:"readTimeout"` // 读取超时时间
	IdleTimeout  *shared.TimeDuration `yaml:"idleTimeout" json:"idleTimeout"` // 空闲连接超时时间
	MaxFails     int                  `yaml:"maxFails" json:"maxFails"`       // 最多失败次数
	MaxConns     int                  `yaml:"maxConns" json:"maxConns"`       // 最大并发连接数
	MaxIdleConns int                  `yaml:"idleConns" json:"idleConns"`     // 最大空闲连接数

	Domains []string `yaml:"domains" json:"domains"` // 所属域名

	StripPrefix    string                `yaml:"stripPrefix" json:"stripPrefix"`       // 去除URL前缀
	RequestURI     string                `yaml:"requestURI" json:"requestURI"`         // 转发后的请求URI
	RequestHost    string                `yaml:"requestHost" json:"requestHost"`       // 自定义主机名
	FollowPort     bool                  `yaml:"followPort" json:"followPort"`         // 端口跟随
	FollowProtocol *FollowProtocolConfig `yaml:"followProtocol" json:"followProtocol"` // 协议跟随

	RequestHeaderPolicyRef  *shared.HTTPHeaderPolicyRef `yaml:"requestHeaderPolicyRef" json:"requestHeaderPolicyRef"`   // 请求Header
	RequestHeaderPolicy     *shared.HTTPHeaderPolicy    `yaml:"requestHeaderPolicy" json:"requestHeaderPolicy"`         // 请求Header策略
	ResponseHeaderPolicyRef *shared.HTTPHeaderPolicyRef `yaml:"responseHeaderPolicyRef" json:"responseHeaderPolicyRef"` // 响应Header`
	ResponseHeaderPolicy    *shared.HTTPHeaderPolicy    `yaml:"responseHeaderPolicy" json:"responseHeaderPolicy"`       // 响应Header策略

	// 健康检查URL，目前支持：
	// - http|https 返回2xx-3xx认为成功
	HealthCheck *HealthCheckConfig `yaml:"healthCheck" json:"healthCheck"` // TODO

	CertRef *sslconfigs.SSLCertRef    `yaml:"certRef" json:"certRef"` // 证书的引用
	Cert    *sslconfigs.SSLCertConfig `yaml:"cert" json:"cert"`       // 请求源服务器用的证书

	// ftp
	FTPServerRef *FTPServerRef    `yaml:"ftpServerRef" json:"ftpServerRef"` // TODO
	FTPServer    *FTPServerConfig `yaml:"ftpServer" json:"ftpServer"`       // TODO

	IsOk bool `yaml:"isOk" json:"isOk"` // 是否可以正常访问，仅仅用于运行时检查
	// contains filtered or unexported fields
}

type OriginGroupConfig struct {
	Origins []*OriginConfig `yaml:"origins" json:"origins"` // 源站列表
}

type OriginRef struct {
	IsOn     bool  `yaml:"isOn" json:"isOn"`
	OriginId int64 `yaml:"originId" json:"originId"`
}

type PlanConfig struct {
	Id   int64  `yaml:"id" json:"id"`
	Name string `yaml:"name" json:"name"`

	TrafficLimit          *TrafficLimitConfig     `yaml:"trafficLimit" json:"trafficLimit"`
	BandwidthLimitPerNode *shared.BitSizeCapacity `yaml:"bandwidthLimitPerNode" json:"bandwidthLimitPerNode"`
	MaxUploadSize         *shared.SizeCapacity    `yaml:"maxUploadSize" json:"maxUploadSize"`
}

type Protocol string

type ProxyProtocolConfig struct {
	IsOn    bool                 `yaml:"isOn" json:"isOn"`
	Version ProxyProtocolVersion `yaml:"version" json:"version"`
}

type ProxyProtocolVersion = int

type ReferersConfig struct {
	IsPrior         bool     `yaml:"isPrior" json:"isPrior"`
	IsOn            bool     `yaml:"isOn" json:"isOn"`
	AllowEmpty      bool     `yaml:"allowEmpty" json:"allowEmpty"`           // 来源域名允许为空
	AllowSameDomain bool     `yaml:"allowSameDomain" json:"allowSameDomain"` // 允许来源域名和当前访问的域名一致，相当于在站内访问
	AllowDomains    []string `yaml:"allowDomains" json:"allowDomains"`       // 允许的来源域名列表
	DenyDomains     []string `yaml:"denyDomains" json:"denyDomains"`         // 禁止的来源域名列表
	CheckOrigin     bool     `yaml:"checkOrigin" json:"checkOrigin"`         // 是否检查Origin

	OnlyURLPatterns   []*shared.URLPattern `yaml:"onlyURLPatterns" json:"onlyURLPatterns"`     // 仅限的URL
	ExceptURLPatterns []*shared.URLPattern `yaml:"exceptURLPatterns" json:"exceptURLPatterns"` // 排除的URL
}

type RequestHostType = int8

type ReverseProxyConfig struct {
	Id                int64             `yaml:"id" json:"id"`                               // ID
	IsOn              bool              `yaml:"isOn" json:"isOn"`                           // 是否启用
	PrimaryOrigins    []*OriginConfig   `yaml:"primaryOrigins" json:"primaryOrigins"`       // 主要源站列表
	PrimaryOriginRefs []*OriginRef      `yaml:"primaryOriginRefs" json:"primaryOriginRefs"` // 主要源站引用
	BackupOrigins     []*OriginConfig   `yaml:"backupOrigins" json:"backupOrigins"`         // 备用源站列表
	BackupOriginRefs  []*OriginRef      `yaml:"backupOriginRefs" json:"backupOriginRefs"`   // 备用源站引用
	Scheduling        *SchedulingConfig `yaml:"scheduling" json:"scheduling"`               // 调度算法选项

	ConnTimeout  *shared.TimeDuration `yaml:"connTimeout" json:"connTimeout"`   // 连接失败超时 TODO
	ReadTimeout  *shared.TimeDuration `yaml:"readTimeout" json:"readTimeout"`   // 读取超时时间 TODO
	IdleTimeout  *shared.TimeDuration `yaml:"idleTimeout" json:"idleTimeout"`   // 空闲连接超时时间 TODO
	MaxFails     int                  `yaml:"maxFails" json:"maxFails"`         // 最多失败次数 TODO
	MaxConns     int                  `yaml:"maxConns" json:"maxConns"`         // 最大并发连接数 TODO
	MaxIdleConns int                  `yaml:"maxIdleConns" json:"maxIdleConns"` // 最大空闲连接数 TODO

	StripPrefix              string          `yaml:"stripPrefix" json:"stripPrefix"`                           // 去除URL前缀
	RequestHostType          RequestHostType `yaml:"requestHostType" json:"requestHostType"`                   // 请求Host类型
	RequestHost              string          `yaml:"requestHost" json:"requestHost"`                           // 请求Host，支持变量
	RequestURI               string          `yaml:"requestURI" json:"requestURI"`                             // 请求URI，支持变量，如果同时定义了StripPrefix，则先执行StripPrefix
	RequestHostExcludingPort bool            `yaml:"requestHostExcludingPort" json:"requestHostExcludingPort"` // 请求Host不包括端口
	Retry50X                 bool            `yaml:"retry50X" json:"retry50X"`                                 // 50x 错误重试
	Retry40X                 bool            `yaml:"retry40X" json:"retry40X"`                                 // 40x 内容重试源站

	AddHeaders []string `yaml:"addHeaders" json:"addHeaders"` // 自动添加的Header

	AutoFlush bool `yaml:"autoFlush" json:"autoFlush"` // 是否自动刷新缓冲区，在比如SSE（server-sent events）场景下很有用

	ProxyProtocol   *ProxyProtocolConfig  `yaml:"proxyProtocol" json:"proxyProtocol"`     // PROXY Protocol
	FollowRedirects bool                  `yaml:"followRedirects" json:"followRedirects"` // 回源跟随
	FollowProtocol  *FollowProtocolConfig `yaml:"followProtocol" json:"followProtocol"`   // 协议跟随 TODO
	// contains filtered or unexported fields
}

type ReverseProxyRef struct {
	IsPrior        bool  `yaml:"isPrior" json:"isPrior"`               // 是否覆盖
	IsOn           bool  `yaml:"isOn" json:"isOn"`                     // 是否启用
	ReverseProxyId int64 `yaml:"reverseProxyId" json:"reverseProxyId"` // 反向代理ID
}

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

type SchedulingGroup struct {
	Scheduling *SchedulingConfig `yaml:"scheduling" json:"scheduling"`

	PrimaryOrigins []*OriginConfig
	BackupOrigins  []*OriginConfig
	// contains filtered or unexported fields
}

type ScriptConfig struct {
	IsPrior bool `yaml:"isPrior" json:"isPrior"`
	IsOn    bool `yaml:"isOn" json:"isOn"`

	Code            string `yaml:"code" json:"code"`                       // 当前运行的代码
	AuditingCode    string `yaml:"auditingCode" json:"auditingCode"`       // 审核中的代码
	AuditingCodeMD5 string `yaml:"auditingCodeMD5" json:"auditingCodeMD5"` // 审核中的代码MD5
	// contains filtered or unexported fields
}

type ScriptGroupConfig struct {
	IsOn    bool            `yaml:"isOn" json:"isOn"`
	IsPrior bool            `yaml:"isPrior" json:"isPrior"`
	Scripts []*ScriptConfig `yaml:"scripts" json:"scripts"`
	// contains filtered or unexported fields
}

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

type ServerConfig struct {
	Id               int64               `yaml:"id" json:"id"`                             // ID
	ClusterId        int64               `yaml:"clusterId" json:"clusterId"`               // 集群ID
	UserId           int64               `yaml:"userId" json:"userId"`                     // 用户ID
	Type             string              `yaml:"type" json:"type"`                         // 类型
	IsOn             bool                `yaml:"isOn" json:"isOn"`                         // 是否开启
	Name             string              `yaml:"name" json:"name"`                         // 名称
	Description      string              `yaml:"description" json:"description"`           // 描述
	AliasServerNames []string            `yaml:"aliasServerNames" json:"aliasServerNames"` // 关联的域名，比如CNAME之类的
	ServerNames      []*ServerNameConfig `yaml:"serverNames" json:"serverNames"`           // 域名
	CNameDomain      string              `yaml:"cnameDomain" json:"cnameDomain"`           // CNAME（末尾不带点（.））
	CNameAsDomain    bool                `yaml:"cnameAsDomain" json:"cnameAsDomain"`       // 启用CNAME域名访问
	SupportCNAME     bool                `yaml:"supportCNAME" json:"supportCNAME"`         // 是否支持CNAME

	// 前端协议
	HTTP  *HTTPProtocolConfig  `yaml:"http" json:"http"`   // HTTP配置
	HTTPS *HTTPSProtocolConfig `yaml:"https" json:"https"` // HTTPS配置
	TCP   *TCPProtocolConfig   `yaml:"tcp" json:"tcp"`     // TCP配置
	TLS   *TLSProtocolConfig   `yaml:"tls" json:"tls"`     // TLS配置
	UDP   *UDPProtocolConfig   `yaml:"udp" json:"udp"`     // UDP配置

	// Web配置
	Web *HTTPWebConfig `yaml:"web" json:"web"`

	// 反向代理配置
	ReverseProxyRef *ReverseProxyRef    `yaml:"reverseProxyRef" json:"reverseProxyRef"`
	ReverseProxy    *ReverseProxyConfig `yaml:"reverseProxy" json:"reverseProxy"`

	// WAF策略
	HTTPFirewallPolicyId int64                               `yaml:"httpFirewallPolicyId" json:"httpFirewallPolicyId"`
	HTTPFirewallPolicy   *firewallconfigs.HTTPFirewallPolicy `yaml:"httpFirewallPolicy" json:"httpFirewallPolicy"` // 通过 HTTPFirewallPolicyId 获取

	// 缓存策略
	HTTPCachePolicyId int64            `yaml:"httpCachePolicyId" json:"httpCachePolicyId"`
	HTTPCachePolicy   *HTTPCachePolicy `yaml:"httpCachePolicy" json:"httpCachePolicy"` // 通过 HTTPCachePolicyId 获取

	// 流量限制
	TrafficLimit       *TrafficLimitConfig `yaml:"trafficLimit" json:"trafficLimit"`
	TrafficLimitStatus *TrafficLimitStatus `yaml:"trafficLimitStatus" json:"trafficLimitStatus"`

	// 套餐
	UserPlan *UserPlanConfig `yaml:"userPlan" json:"userPlan"`

	// 分组
	Group *ServerGroupConfig `yaml:"group" json:"group"`

	// UAM
	UAM *UAMConfig `yaml:"uam" json:"uam"`
	// contains filtered or unexported fields
}

type ServerGroupConfig struct {
	Id   int64  `yaml:"id" json:"id"`
	Name string `yaml:"name" json:"name"`
	IsOn bool   `yaml:"isOn" json:"isOn"`

	// 反向代理配置
	HTTPReverseProxyRef *ReverseProxyRef    `yaml:"httpReverseProxyRef" json:"httpReverseProxyRef"`
	HTTPReverseProxy    *ReverseProxyConfig `yaml:"httpReverseProxy" json:"httpReverseProxy"`
	TCPReverseProxyRef  *ReverseProxyRef    `yaml:"tcpReverseProxyRef" json:"tcpReverseProxyRef"`
	TCPReverseProxy     *ReverseProxyConfig `yaml:"tcpReverseProxy" json:"tcpReverseProxy"`
	UDPReverseProxyRef  *ReverseProxyRef    `yaml:"udpReverseProxyRef" json:"udpReverseProxyRef"`
	UDPReverseProxy     *ReverseProxyConfig `yaml:"udpReverseProxy" json:"udpReverseProxy"`

	Web *HTTPWebConfig `yaml:"web" json:"web"`
}

type ServerNameConfig struct {
	Name     string   `yaml:"name" json:"name"`         // 名称
	Type     string   `yaml:"type" json:"type"`         // 类型
	SubNames []string `yaml:"subNames" json:"subNames"` // 子名称，用来支持大量的域名批量管理
}

type ServerNameType = string

type ServerType = string

type TCPProtocolConfig struct {
	BaseProtocol `yaml:",inline"`
}