models

type Accounts struct {

	/* 账号名称 (Optional) */
	AccountName string `json:"accountName"`

	/* 账号类型。如果为default则为默认账号；如果为normal则为普通账号 (Optional) */
	AccountType string `json:"accountType"`

	/* 账号权限 (Optional) */
	AccountPrivilege string `json:"accountPrivilege"`

	/* 账号描述 (Optional) */
	AccountDescription string `json:"accountDescription"`
}

type AdminHealth struct {

	/* 健康状态 (Optional) */
	Health string `json:"health"`

	/* configmap网络状态是否符合预期 (Optional) */
	ConfigMapNetWorkExpected bool `json:"configMapNetWorkExpected"`

	/* nlb网络状态是否符合预期 (Optional) */
	NlbNetWorkExpected bool `json:"nlbNetWorkExpected"`
}

type AvailableCPUArch struct {

	/* CPU架构详情 (Optional) */
	CpuArchInfo CpuArchInfo `json:"cpuArchInfo"`

	/* 是否售罄 (Optional) */
	SoldOut bool `json:"soldOut"`

	/* 售卖内存规格列表 (Optional) */
	AvailableMemorySpecs []AvailableMemorySpec `json:"availableMemorySpecs"`

	/* 支持最小分片数 (Optional) */
	ShardNumberMin int `json:"shardNumberMin"`

	/* 支持最大分片数 (Optional) */
	ShardNumberMax int `json:"shardNumberMax"`

	/* 支持的最大内存规格 (Optional) */
	MaxMemoryMB int `json:"maxMemoryMB"`
}

type AvailableEngineVersion struct {

	/* redis引擎主从版本号，目前支持：2.8、4.0 (Optional) */
	Version string `json:"version"`

	/* 是否推荐 (Optional) */
	Recommended bool `json:"recommended"`

	/* 是否售罄 (Optional) */
	SoldOut bool `json:"soldOut"`

	/* 是否必须有代理 (Optional) */
	MustEnableSmartProxy bool `json:"mustEnableSmartProxy"`

	/* 售卖CPU架构列表 (Optional) */
	AvailableCPUArchs []AvailableCPUArch `json:"availableCPUArchs"`
}

type AvailableFlavor struct {

	/* 分片数 (Optional) */
	ShardNumber int `json:"shardNumber"`

	/* IP数 (Optional) */
	IpNumber int `json:"ipNumber"`

	/* 不同副本的IP数 (Optional) */
	IpNumbers interface{} `json:"ipNumbers"`

	/* 是否推荐 (Optional) */
	Recommended bool `json:"recommended"`

	/* 规格代码，标准版为实例的规格代码；集群版为单分片规格代码 (Optional) */
	InstanceClasses []string `json:"instanceClasses"`

	/* 规格详情 (Optional) */
	Detail FlavorDetail `json:"detail"`
}

type AvailableMemorySpec struct {

	/* 售卖内存（GB） (Optional) */
	MemoryGB int `json:"memoryGB"`

	/* 售卖内存（MB） (Optional) */
	MemoryMB int `json:"memoryMB"`

	/* 是否售罄 (Optional) */
	SoldOut bool `json:"soldOut"`

	/* 可用区列表 (Optional) */
	AvailableZones []AzInfo `json:"availableZones"`

	/* 规格列表 (Optional) */
	AvailableFlavors []AvailableFlavor `json:"availableFlavors"`
}

type AvailableRegion struct {

	/* 地域id (Optional) */
	RegionId string `json:"regionId"`

	/* 地域名 (Optional) */
	RegionName string `json:"regionName"`

	/* 是否售罄 (Optional) */
	SoldOut bool `json:"soldOut"`

	/* 用户配额 (Optional) */
	Quota QuotaInfo `json:"quota"`

	/* 可用区列表 (Optional) */
	AvailableZones []AzInfo `json:"availableZones"`
}

type AvailableResource struct {

	/* 架构类型，目前支持：master-slave（标准版）、cluster（代理集群版）、native-cluster（cluster集群版） (Optional) */
	ArchitectureType string `json:"architectureType"`

	/* 架构类型名 (Optional) */
	ArchitectureName string `json:"architectureName"`

	/* 是否推荐 (Optional) */
	Recommended bool `json:"recommended"`

	/* 是否售罄 (Optional) */
	SoldOut bool `json:"soldOut"`

	/* 支持的最大副本数 (Optional) */
	SupportedMaxReplicas int `json:"supportedMaxReplicas"`

	/* 支持的最小副本数 (Optional) */
	SupportedMinReplicas int `json:"supportedMinReplicas"`

	/* 支持的AZ指定方式：SpecifyByReplicaGroup表示按副本组指定，SpecifyByCluster表示按整个集群指定 (Optional) */
	SupportedAzSpecifyType []string `json:"supportedAzSpecifyType"`

	/* 按集群指定AZ时，需要指定的最小AZ个数 (Optional) */
	MinAzLimitForCluster int `json:"minAzLimitForCluster"`

	/* 支持的外部访问方式：NodePort、LoadBalancer (Optional) */
	SupportedExposeType []string `json:"supportedExposeType"`

	/* 是否支持SmartProxy (Optional) */
	SupportSmartProxy bool `json:"supportSmartProxy"`

	/* 引擎版本列表 (Optional) */
	AvailableEngineVersions []AvailableEngineVersion `json:"availableEngineVersions"`
}

type AzId struct {

	/* AZ指定方式，SpecifyByReplicaGroup表示按副本组指定，SpecifyByCluster表示按整个集群指定 (Optional) */
	AzSpecifyType string `json:"azSpecifyType"`

	/* 为集群指定的AZ范围，按集群指定AZ时生效 (Optional) */
	AzsForCluster []string `json:"azsForCluster"`

	/* 缓存Redis主实例所在区域的可用区ID，按副本组指定AZ时生效 (Optional) */
	Master string `json:"master"`

	/* 缓存Redis从实例所在区域的可用区ID，按副本组指定AZ时生效 (Optional) */
	Slave string `json:"slave"`

	/* 代理AZ范围 (Optional) */
	AzsForProxy []string `json:"azsForProxy"`
}

type AzIdSpec struct {

	/* AZ指定方式，SpecifyByReplicaGroup表示按副本组指定，SpecifyByCluster表示按整个集群指定 (Optional) */
	AzSpecifyType *string `json:"azSpecifyType"`

	/* 为集群指定的AZ范围，按集群指定AZ时生效 (Optional) */
	AzsForCluster []string `json:"azsForCluster"`

	/* 缓存Redis主实例所在的可用区ID，按副本组指定AZ时生效  */
	Master string `json:"master"`

	/* 缓存Redis从实例所在的可用区ID，按副本组指定AZ时生效  */
	Slave string `json:"slave"`

	/* 代理AZ范围 (Optional) */
	AzsForProxy []string `json:"azsForProxy"`
}

type AzInfo struct {

	/* 逻辑可用区id (Optional) */
	AzId string `json:"azId"`

	/* 逻辑可用区名 (Optional) */
	AzName string `json:"azName"`

	/* 是否售罄 (Optional) */
	SoldOut bool `json:"soldOut"`
}

type AzSaleStatusVo struct {

	/* 物理az (Optional) */
	Az string `json:"az"`

	/* 是否售罄(0未售罄，1售罄) (Optional) */
	CanSale int `json:"canSale"`

	/* 是否可见(1可见，0不可见) (Optional) */
	Visible int `json:"visible"`
}

type Backup struct {

	/* 备份操作ID  */
	BaseId string `json:"baseId"`

	/* 备份文件的名称  */
	BackupFileName string `json:"backupFileName"`

	/* 备份文件对应的实例ID  */
	CacheInstanceId string `json:"cacheInstanceId"`

	/* 备份开始时间（ISO 8601标准的UTC时间，格式为：YYYY-MM-DDTHH:mm:ssZ）  */
	BackupStartTime string `json:"backupStartTime"`

	/* 备份结束时间（ISO 8601标准的UTC时间，格式为：YYYY-MM-DDTHH:mm:ssZ）  */
	BackupEndTime string `json:"backupEndTime"`

	/* 备份类型，1表示手动备份，0表示自动备份  */
	BackupType int `json:"backupType"`

	/* 备份文件总字节大小，如果实例是集群版，则表示每个分片备份文件大小的总和  */
	BackupSize int64 `json:"backupSize"`

	/* 备份任务状态状态，0表示备份中，1表示失败，2表示成功  */
	BackupStatus int `json:"backupStatus"`

	/* 备份时刻分片的内存规格 (Optional) */
	BackupShardMemoryMB int `json:"backupShardMemoryMB"`

	/* 备份分片数 (Optional) */
	BackupShardNum int `json:"backupShardNum"`

	/* 备份文件下载地址（已废弃，调用获取备份文件下载地址接口获取）  */
	BackupDownloadURL string `json:"backupDownloadURL"`
}

type BackupFile struct {

	/* 备份文件的名称 (Optional) */
	BackupFileName string `json:"backupFileName"`

	/* 备份ID (Optional) */
	BackupId string `json:"backupId"`

	/* redis节点 (Optional) */
	RedisNode string `json:"redisNode"`

	/* 备份文件的开始时间（ISO 8601标准的UTC时间，格式为：YYYY-MM-DDTHH:mm:ssZ） (Optional) */
	BackupStartTime string `json:"backupStartTime"`
}

type BackupInfoExtension struct {

	/* 实例备份时刻的regionId (Optional) */
	RegionId string `json:"regionId"`

	/* 实例备份时刻的redis版本 (Optional) */
	RedisVersion string `json:"redisVersion"`

	/* 实例备份时刻的platform (Optional) */
	Platform string `json:"platform"`

	/* 实例备份时刻的架构类型 (Optional) */
	CacheInstanceType string `json:"cacheInstanceType"`

	/* 实例备份时刻的cpu架构 (Optional) */
	CpuArchType string `json:"cpuArchType"`

	/* 实例备份时刻的db数 (Optional) */
	DatabaseNum int `json:"databaseNum"`

	/* 实例的副本数 (Optional) */
	ReplicaNumber int `json:"replicaNumber"`
}

type BaseProductRegionVo struct {

	/* 产品编码 (Optional) */
	ServiceCode string `json:"serviceCode"`

	/* 区域售卖状态列表 (Optional) */
	RegionAzVos []RegionAzVo `json:"regionAzVos"`
}

type BigKeyAnalysisNode struct {

	/* 节点id (Optional) */
	NodeId string `json:"nodeId"`

	/* 节点角色，master/slave (Optional) */
	NodeRole string `json:"nodeRole"`

	/* String类型大key数量 (Optional) */
	StringTypeNum int `json:"stringTypeNum"`

	/* List类型大key数量 (Optional) */
	ListTypeNum int `json:"listTypeNum"`

	/* Set类型大key数量 (Optional) */
	SetTypeNum int `json:"setTypeNum"`

	/* Hash类型大key数量 (Optional) */
	HashTypeNum int `json:"hashTypeNum"`

	/* Zset类型大key数量 (Optional) */
	ZsetTypeNum int `json:"zsetTypeNum"`
}

type CacheAnalysis struct {

	/* 缓存分析的时间,rfc3339格式  */
	AnalysisTime string `json:"analysisTime"`

	/* 缓存分析的任务ID  */
	TaskId string `json:"taskId"`

	/* 缓存分析任务状态, running, success, error, 只有sucess状态，才能根据taskId查询到结果 (Optional) */
	Status string `json:"status"`
}

type CacheInstance struct {

	/* 实例ID (Optional) */
	CacheInstanceId string `json:"cacheInstanceId"`

	/* 实例名称 (Optional) */
	CacheInstanceName string `json:"cacheInstanceName"`

	/* 规格代码，2.8、4.0标准版是实例规格，4.0自定义分片集群版实例表示单分片规格 (Optional) */
	CacheInstanceClass string `json:"cacheInstanceClass"`

	/* 实例的总内存（MB），表示用户购买的可使用内存 (Optional) */
	CacheInstanceMemoryMB int `json:"cacheInstanceMemoryMB"`

	/* 实例状态：creating表示创建中，running表示运行中，error表示错误，changing表示变更规格中，deleting表示删除中，configuring表示修改参数中，restoring表示备份恢复中，upgrading表示升级中 (Optional) */
	CacheInstanceStatus string `json:"cacheInstanceStatus"`

	/* 实例描述 (Optional) */
	CacheInstanceDescription string `json:"cacheInstanceDescription"`

	/* 创建时间（ISO 8601标准的UTC时间，格式为：YYYY-MM-DDTHH:mm:ssZ） (Optional) */
	CreateTime string `json:"createTime"`

	/* 软删除时间，即实例进入回收站的时间（ISO 8601标准的UTC时间，格式为：YYYY-MM-DDTHH:mm:ssZ） (Optional) */
	SoftDeletedTime string `json:"softDeletedTime"`

	/* 回收站实例的过期时间（ISO 8601标准的UTC时间，格式为：YYYY-MM-DDTHH:mm:ssZ） (Optional) */
	RetainExpireTime string `json:"retainExpireTime"`

	/* az信息 (Optional) */
	AzId AzId `json:"azId"`

	/* 实例所属VPC ID (Optional) */
	VpcId string `json:"vpcId"`

	/* 实例所属子网ID (Optional) */
	SubnetId string `json:"subnetId"`

	/* 实例的访问域名 (Optional) */
	ConnectionDomain string `json:"connectionDomain"`

	/* 实例的访问端口 (Optional) */
	Port int `json:"port"`

	/* 实例的计费信息 (Optional) */
	Charge charge.Charge `json:"charge"`

	/* 实例Redis的详细版本号，形如x.x-x.x (Optional) */
	InstanceVersion string `json:"instanceVersion"`

	/* 实例Proxy的详细版本号，形如x.x-x.x (Optional) */
	InstanceProxyVersion string `json:"instanceProxyVersion"`

	/* 连接实例时，是否需要密码认证，false表示无密码 (Optional) */
	Auth bool `json:"auth"`

	/* 实例是否允许修改为免密 (Optional) */
	IsAllowNoAuth bool `json:"isAllowNoAuth"`

	/* 创建实例时选择的引擎版本：目前支持2.8和4.0 (Optional) */
	RedisVersion string `json:"redisVersion"`

	/* 实例类型：master-slave（标准版）、cluster（代理集群版）、native-cluster（cluster集群版） (Optional) */
	CacheInstanceType string `json:"cacheInstanceType"`

	/* 是否支持IPv6，0表示不支持（只能用IPv4），1表示支持 (Optional) */
	Ipv6On int `json:"ipv6On"`

	/* 标签信息 (Optional) */
	Tags []Tag `json:"tags"`

	/* 实例所属资源组ID (Optional) */
	ResourceGroupId string `json:"resourceGroupId"`

	/* 实例分片数，标准版固定为1，自定义分片集群版实例分片数由用户创建时选择，其他实例为固定分片数 (Optional) */
	ShardNumber int `json:"shardNumber"`

	/* 单分片内存大小（MB） (Optional) */
	MemoryMBPerShard int `json:"memoryMBPerShard"`

	/* 扩展配置 (Optional) */
	Extension RespExtension `json:"extension"`

	/* 实例其他访问域名列表 (Optional) */
	OtherDomains []InstanceDomain `json:"otherDomains"`

	/* 从节点aof开关 (Optional) */
	SlaveAppendonly string `json:"slaveAppendonly"`

	/* db数量 (Optional) */
	DatabaseNum string `json:"databaseNum"`

	/* 淘汰策略 (Optional) */
	MaxmemoryPolicy string `json:"maxmemoryPolicy"`

	/* 副本数，含主副本 (Optional) */
	ReplicaNumber int `json:"replicaNumber"`

	/* 实例是否开启SmartProxy，当架构类型为native-cluster时才有效，1表示开启，0表示不开启 (Optional) */
	EnableSmartProxy int `json:"enableSmartProxy"`

	/* cpu架构类型:arm64、amd64 (Optional) */
	CpuArchType string `json:"cpuArchType"`

	/* 可维护时间段的开始时间，格式为HH:mmZ（UTC时间） (Optional) */
	MaintenanceStartTime string `json:"maintenanceStartTime"`

	/* 可维护时间段的结束时间，格式为HH:mmZ（UTC时间） (Optional) */
	MaintenanceEndTime string `json:"maintenanceEndTime"`

	/* 实例待执行的任务 (Optional) */
	ToBeExecutedTaskType []int `json:"toBeExecutedTaskType"`

	/* 是否支持绑定弹性公网IP (Optional) */
	SupportAssociateEIP bool `json:"supportAssociateEIP"`

	/* 平台 (Optional) */
	Platform string `json:"platform"`
}

type CacheInstanceSpec struct {

	/* 缓存Redis实例所属的私有网络ID  */
	VpcId string `json:"vpcId"`

	/* 缓存Redis实例在私有网络下所属的子网ID  */
	SubnetId string `json:"subnetId"`

	/* 缓存Redis实例名称，只支持数字、字母、英文下划线、中文，且不少于2字符不超过32字符  */
	CacheInstanceName string `json:"cacheInstanceName"`

	/* 缓存Redis实例的规格代码（可调用describeInstanceClass接口获取），或者自定义分片实例的单分片规格代码（可调用describeSpecConfig接口获取）  */
	CacheInstanceClass string `json:"cacheInstanceClass"`

	/* 缓存Redis实例的连接密码，为空即为免密，包含且只支持字母及数字，不少于8字符不超过16字符 (Optional) */
	Password *string `json:"password"`

	/* 缓存Redis实例所在区域的可用区ID  */
	AzId *AzIdSpec `json:"azId"`

	/* 缓存Redis实例的描述，不能超过256个字符 (Optional) */
	CacheInstanceDescription *string `json:"cacheInstanceDescription"`

	/* 缓存Redis引擎主次版本号：目前支持2.8和4.0，默认为2.8 (Optional) */
	RedisVersion *string `json:"redisVersion"`

	/* 是否支持IPv6，0或空表示不支持，1表示支持IPv6，注意不是所有区域都支持IPv6，且必须保证VPC支持IPv6 (Optional) */
	Ipv6On *int `json:"ipv6On"`

	/* 分片数，自定义分片规格集群版实例必须有，且大于1。每种分片规格支持的分片数可调用describeSpecConfig接口获取 (Optional) */
	ShardNumber *int `json:"shardNumber"`

	/* 用户普通标签 (Optional) */
	UserTags []Tag `json:"userTags"`

	/* 缓存Redis实例所属的资源组ID (Optional) */
	ResourceGroupId *string `json:"resourceGroupId"`

	/* db数量，默认为16，参数范围为16~256 (Optional) */
	DbNum *int `json:"dbNum"`

	/* slave节点是否开启持久化 (Optional) */
	SlaveAppendonly *string `json:"slaveAppendonly"`

	/* 内存淘汰策略 (Optional) */
	MaxmemoryPolicy *string `json:"maxmemoryPolicy"`

	/* 缓存Redis实例类型，目前支持：master-slave（标准版）、cluster（代理集群版）、native-cluster（cluster集群版） (Optional) */
	CacheInstanceType *string `json:"cacheInstanceType"`

	/* 副本数，含主副本 (Optional) */
	ReplicaNumber *int `json:"replicaNumber"`

	/* 实例是否开启SmartProxy，当架构类型为native-cluster时才有效，1表示开启，0表示不开启 (Optional) */
	EnableSmartProxy *int `json:"enableSmartProxy"`

	/* 缓存Redis实例访问端口 (Optional) */
	Port *int `json:"port"`

	/* 扩展配置 (Optional) */
	Extension *ReqExtension `json:"extension"`

	/* cpu架构类型:arm64、amd64 (Optional) */
	CpuArchType *string `json:"cpuArchType"`

	/* 从备份克隆实例时，指定备份的baseId,需要与srcInstanceId同时指定 (Optional) */
	BackupId *string `json:"backupId"`

	/* 从备份克隆实例时，指定的备份实例的instanceId,需要与backupId同时指定 (Optional) */
	SrcInstanceId *string `json:"srcInstanceId"`

	/* 配置模板ID (Optional) */
	ConfigTemplateId *string `json:"configTemplateId"`

	/* 容器标签信息 (Optional) */
	OpsTags []OpsTag `json:"opsTags"`
}

type ChartRelease struct {

	/* chart组件  */
	Chart string `json:"chart"`

	/* chart版本  */
	Version string `json:"version"`

	/* chart名  */
	ChartName string `json:"chartName"`

	/* chart状态  */
	Status string `json:"status"`

	/* 是否是默认chart  */
	IsDefault bool `json:"isDefault"`

	/* 版本描述  */
	Description string `json:"description"`

	/* 版本创建时间  */
	CreatedTime string `json:"createdTime"`
}

type ClearDataTaskInfo struct {

	/* 数据清理任务类型 (Optional) */
	ClearType string `json:"clearType"`

	/* 匹配模式, 如: test*、*test、ab*cc*, 当节点为AllData、ExpiredData时可以忽略此参数 (Optional) */
	KeyPattern string `json:"keyPattern"`

	/* key的过滤条件, 当节点为AllData、ExpiredData时可以忽略此参数 (Optional) */
	KeyFilter []KeyFilter `json:"keyFilter"`

	/* 数据遍历的速率 (Optional) */
	QpsLimit int `json:"qpsLimit"`

	/* 本次清理任务的完成进度 (Optional) */
	Progress int `json:"progress"`

	/* 本次清理任务已成功清理的key数量 (Optional) */
	EffectKeys int `json:"effectKeys"`

	/* 本次清理任务的状态:running、success、failed (Optional) */
	Status string `json:"status"`

	/* 本次清理任务失败的原因 (Optional) */
	Message string `json:"message"`

	/* 最近一次status转换的时间 (Optional) */
	LastTransitionTime string `json:"lastTransitionTime"`
}

type ClientInfo struct {

	/* 实例名称 (Optional) */
	InstanceName string `json:"instanceName"`

	/* 客户端版本号 (Optional) */
	Version string `json:"version"`

	/* 客户端ip (Optional) */
	Ip string `json:"ip"`

	/* 进程pid/tid/随机数 (Optional) */
	Pid string `json:"pid"`

	/* UUID (Optional) */
	Uuid string `json:"uuid"`

	/* 客户端启动时间 (Optional) */
	StartTime string `json:"startTime"`
}

type ClusterCacheAnalysis struct {

	/* 缓存分析的开始时间,rfc3339格式  */
	AnalysisTime string `json:"analysisTime"`

	/* 缓存分析的任务ID  */
	TaskId string `json:"taskId"`

	/* 缓存分析的分析时长  */
	AnalysisDuration string `json:"analysisDuration"`

	/* 缓存分析的结果下载地址  */
	DownloadUrl string `json:"downloadUrl"`

	/* 缓存分析任务状态, running, success, error, 只有sucess状态，才能根据taskId查询到结果  */
	Status string `json:"status"`
}

type ClusterInfo struct {

	/* 代理列表 (Optional) */
	Proxies []Proxy `json:"proxies"`

	/* 分片列表 (Optional) */
	Shards []Shard `json:"shards"`

	/* redis列表 (Optional) */
	Redis []Redis `json:"redis"`
}

type CommandHistory struct {

	/* 实例id (Optional) */
	InstanceId string `json:"instanceId"`

	/* 对应命令执行的结果 (Optional) */
	Pin string `json:"pin"`

	/* 命令执行的数据库id号 (Optional) */
	Database int `json:"database"`

	/* 命令执行耗时,单位毫秒 (Optional) */
	Delay int `json:"delay"`

	/* 命令执行状态(succeed:执行成功,failed:执行失败) (Optional) */
	ExecuteState string `json:"executeState"`

	/* 对应执行的命令 (Optional) */
	Command string `json:"command"`

	/* 命令执行时间（ISO 8601标准的UTC时间，格式为：YYYY-MM-DDTHH:mm:ssZ） (Optional) */
	ExecuteDate string `json:"executeDate"`

	/* 命令执行失败的原因 (Optional) */
	Info string `json:"info"`
}

type Conditions struct {

	/* condition类型 (Optional) */
	Type string `json:"type"`

	/* condition名称 (Optional) */
	Name string `json:"name"`

	/* condition执行的原因 (Optional) */
	Reason string `json:"reason"`

	/* condition执行的信息 (Optional) */
	Message string `json:"message"`

	/* condition状态 (Optional) */
	Status string `json:"status"`

	/* 对应的任务ID (Optional) */
	TaskId string `json:"taskId"`

	/* 创建时间 (Optional) */
	Createtime string `json:"createtime"`

	/* 更新时间 (Optional) */
	Updatetime string `json:"updatetime"`
}

type Config struct {

	/* redis参数 (Optional) */
	CommonConfigs *interface{} `json:"commonConfigs"`

	/* master参数 (Optional) */
	MasterConfigs *interface{} `json:"masterConfigs"`

	/* slave参数 (Optional) */
	SlaveConfigs *interface{} `json:"slaveConfigs"`

	/* proxy参数 (Optional) */
	ProxyConfigs *interface{} `json:"proxyConfigs"`
}

type ConfigItem struct {

	/* configName目前只支持以下参数：
	maxmemory-policy（redis 2.8和redis 4.0都支持，但配置值不相同）：内存剔除策略的最大使用内存限制
	hash-max-ziplist-entries（redis 2.8和redis 4.0都支持）：用ziplist编码实现的哈希对象，ziplist中最多能存放entry个数的阈值
	hash-max-ziplist-value（redis 2.8和redis 4.0都支持）：用ziplist编码实现的哈希对象，ziplist中能存放的value长度的最大值
	list-max-ziplist-entries（只有redis 2.8支持）：用ziplist编码实现的列表对象，ziplist中最多能存放entry个数的阈值
	list-max-ziplist-value（只有redis 2.8支持）：用ziplist编码实现的列表对象，ziplist中能存放的value长度的最大值
	list-max-ziplist-size（只有redis 4.0支持）：用ziplist编码实现的列表对象，按照数据项个数或占用的字节数，限定ziplist的长度
	list-compress-depth（只有redis 4.0支持）：用ziplist编码实现的列表对象，quicklist两端不被压缩的节点个数
	set-max-intset-entries（redis 2.8和redis 4.0都支持）：用intset编码实现的集合对象，intset中最多能存放entry个数的阈值
	zset-max-ziplist-entries（redis 2.8和redis 4.0都支持）：用ziplist编码实现的有序集合对象，ziplist中最多能存放entry个数的阈值
	zset-max-ziplist-value（redis 2.8和redis 4.0都支持）：用ziplist编码实现的有序集合对象，ziplist中能存放的value长度的最大值
	slowlog-log-slower-than（redis 2.8和redis 4.0都支持）：慢查询日志超时时间，单位微秒（1000000表示1秒），0表示记录所有的命令
	notify-keyspace-events（只有redis 4.0支持）：事件通知
	*/
	ConfigName string `json:"configName"`

	/* 参数的配置值，默认值、参考值如下：
	maxmemory-policy（redis 2.8和redis 4.0的默认值都为volatile-lru）：redis 4.0 的参考值有[volatile-lru, allkeys-lru, volatile-lfu, allkeys-lfu, volatile-random, allkeys-random, volatile-ttl, noeviction]，redis 2.8的参考值有[volatile-lru , allkeys-lru , volatile-random , allkeys-random , volatile-ttl , noeviction]
	hash-max-ziplist-entries（redis 2.8和redis 4.0的默认值都为512）：[0-10000]
	hash-max-ziplist-value（redis 2.8和redis 4.0的默认值都为64）：[0-10000]
	list-max-ziplist-entries（redis 2.8的默认值为512，redis 4.0不支持）：[0-10000]
	list-max-ziplist-value（redis 2.8的默认值为64，redis 4.0不支持）：[0-10000]
	list-max-ziplist-size（redis 4.0的默认值为-2，redis 2.8不支持）：[-5-10000]
	list-compress-depth（redis 4.0的默认值为0，redis 2.8不支持）：[0-10000]
	set-max-intset-entries（redis 2.8和redis 4.0的默认值都为512）：[0-10000]
	zset-max-ziplist-entries（redis 2.8和redis 4.0的默认值都为128）：[0-10000]
	zset-max-ziplist-value（redis 2.8和redis 4.0的默认值都为64）：[0-10000]
	slowlog-log-slower-than（redis 2.8和redis 4.0的默认值都为10000）：[0-10000]
	notify-keyspace-events（redis 4.0的默认值为空，redis 2.8不支持）：[K , E , g , $ , l , s , h , z , x , e , A]字母的组合，区分大小写，或为空
	*/
	ConfigValue string `json:"configValue"`

	/* 参数默认值 (Optional) */
	ConfigDefaultValue *string `json:"configDefaultValue"`

	/* 参数值类型，目前有int、string、outputBuffer、byteArray这四种 (Optional) */
	ConfigValueType *string `json:"configValueType"`

	/* 参数值的最小值，在configValueType为int时有效 (Optional) */
	ConfigValueMin *int `json:"configValueMin"`

	/* 参数值的最大值，在configValueType为int时有效 (Optional) */
	ConfigValueMax *int `json:"configValueMax"`

	/* 参数值的可选值，在configValueType为string或byteArray时有效 (Optional) */
	ConfigValueOptional []string `json:"configValueOptional"`

	/* configValueType为outputBuffer时的参数值规则 (Optional) */
	ConfigValueOutputBuffer *string `json:"configValueOutputBuffer"`

	/* 参数说明 (Optional) */
	ConfigDescription *string `json:"configDescription"`

	/* 配置项是否不支持 (Optional) */
	ConfigUnSupport *bool `json:"configUnSupport"`
}

type ConfigTemplate struct {

	/* 模板ID (Optional) */
	TemplateId string `json:"templateId"`

	/* 模板名称 (Optional) */
	Name string `json:"name"`

	/* 模板描述 (Optional) */
	Description string `json:"description"`

	/* 配置项列表 (Optional) */
	Val []ConfigItem `json:"val"`

	/* Redis类型(master-slave/native-cluster) (Optional) */
	RedisType string `json:"redisType"`

	/* Redis版本(6.2/7.2/8.0等) (Optional) */
	RedisVersion string `json:"redisVersion"`

	/* 模板类型(default/user) (Optional) */
	TplType string `json:"tplType"`

	/* 用户名 (Optional) */
	User string `json:"user"`

	/* 用户PIN (Optional) */
	Pin string `json:"pin"`

	/* 创建时间 (Optional) */
	CreatedTime string `json:"createdTime"`

	/* 修改时间 (Optional) */
	ModifiedTime string `json:"modifiedTime"`
}

type Container struct {

	/* 容器名 (Optional) */
	ContainerName string `json:"containerName"`

	/* 容器imageTag (Optional) */
	ImageTag string `json:"imageTag"`

	/* 容器状态 (Optional) */
	Status string `json:"status"`

	/* 容器request (Optional) */
	Request string `json:"request"`

	/* 容器限制 (Optional) */
	Limit string `json:"limit"`

	/* 容器重启次数 (Optional) */
	Restart int `json:"restart"`
}

type CpuArchInfo struct {

	/* CPU架构类型 (Optional) */
	CpuType string `json:"cpuType"`

	/* CPU架构显示名称 (Optional) */
	CpuName string `json:"cpuName"`
}

type CreateConfigTemplate struct {

	/* 模板名称  */
	Name string `json:"name"`

	/* 模板描述 (Optional) */
	Description string `json:"description"`

	/* 配置项键值对 (Optional) */
	Val interface{} `json:"val"`

	/* Redis类型(master-slave/native-cluster)  */
	RedisType string `json:"redisType"`

	/* Redis版本(6.2/7.2/8.0等)  */
	RedisVersion string `json:"redisVersion"`
}

type DefaultFilterValue struct {

	/* tp999 (Optional) */
	Tp999 int `json:"tp999"`

	/* tp99 (Optional) */
	Tp99 int `json:"tp99"`

	/* tp90 (Optional) */
	Tp90 int `json:"tp90"`

	/* tp50 (Optional) */
	Tp50 int `json:"tp50"`
}

type Details struct {

	/* client名称  */
	Name string `json:"name"`

	/* client的端口  */
	Port string `json:"port"`

	/* client的已连接时长，单位：秒  */
	Age string `json:"age"`

	/* client的空闲时长，单位：秒  */
	Idle string `json:"idle"`

	/* client连接的db  */
	Db string `json:"db"`

	/* 最近执行的命令名称  */
	LastCmd string `json:"lastCmd"`
}

type DiagnoseBasicInfo struct {

	/* 实例ID  */
	InstanceId string `json:"instanceId"`

	/* 实例名称  */
	InstanceName string `json:"instanceName"`

	/* Redis版本 (Optional) */
	RedisVersion string `json:"redisVersion"`

	/* 实例类型 (Optional) */
	CacheInstanceType string `json:"cacheInstanceType"`

	/* 分片数 (Optional) */
	ShardNumber int `json:"shardNumber"`

	/* 每分片内存（MB） (Optional) */
	MemoryMBPerShard int `json:"memoryMBPerShard"`

	/* 副本数 (Optional) */
	ReplicaNumber int `json:"replicaNumber"`

	/* 可用区信息 (Optional) */
	AzId AzId `json:"azId"`

	/* 诊断开始时间（RFC3339格式）  */
	StartTime string `json:"startTime"`

	/* 诊断结束时间（RFC3339格式） (Optional) */
	EndTime string `json:"endTime"`
}

type DiagnoseItem struct {

	/* 诊断项描述  */
	Desc string `json:"desc"`

	/* 扣分分值  */
	Penalty int `json:"penalty"`

	/* 详情列表 (Optional) */
	Items []string `json:"items"`

	/* 诊断建议 (Optional) */
	Advice string `json:"advice"`

	/* 诊断说明 (Optional) */
	Explanation string `json:"explanation"`
}

type DiagnoseNodeStatus struct {

	/* 诊断项名称  */
	DiagnoseItem string `json:"diagnoseItem"`

	/* 最大值  */
	Max float32 `json:"max"`

	/* 最小值  */
	Min float32 `json:"min"`

	/* 平均值  */
	Avg float32 `json:"avg"`

	/* 是否存在倾斜  */
	IsTilting bool `json:"isTilting"`

	/* 倾斜节点列表 (Optional) */
	TiltingNode []string `json:"tiltingNode"`
}

type DiagnoseOverrideMetric struct {

	/* 指标名称  */
	Name string `json:"name"`

	/* 阈值 (Optional) */
	Threshold *float32 `json:"threshold"`

	/* 扣分分值 (Optional) */
	Penalty *int `json:"penalty"`
}

type DiagnosePerformance struct {

	/* Redis节点状态列表 (Optional) */
	RedisNodeStatus []DiagnoseNodeStatus `json:"redisNodeStatus"`

	/* Proxy节点状态列表 (Optional) */
	ProxyNodeStatus []DiagnoseNodeStatus `json:"proxyNodeStatus"`
}

type DiagnosePolicy struct {

	/* 实例ID  */
	InstanceId string `json:"instanceId"`

	/* 是否开启自动诊断  */
	AutoDiagnose bool `json:"autoDiagnose"`

	/* 诊断时间段（格式：HH:mm-HH:mm +ZZZZ，例如：01:00-02:00 +0800） (Optional) */
	DiagnoseTime string `json:"diagnoseTime"`

	/* 诊断周期（格式：Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday） (Optional) */
	DiagnosePeriod string `json:"diagnosePeriod"`

	/* 下次自动诊断时间 (Optional) */
	NextDiagnoseTime string `json:"nextDiagnoseTime"`
}

type DiagnoseSlowLog struct {

	/* 分片ID (Optional) */
	ShardId string `json:"shardId"`

	/* 执行的命令 (Optional) */
	Command string `json:"command"`

	/* 开始时间 (Optional) */
	StartTime string `json:"startTime"`

	/* 执行耗时 (Optional) */
	ExecutionTime string `json:"executionTime"`

	/* 客户端地址 (Optional) */
	ClientAddr string `json:"clientAddr"`

	/* 客户端名称 (Optional) */
	ClientName string `json:"clientName"`
}

type DiagnoseSummary struct {

	/* 健康评分（0-100）  */
	Score int `json:"score"`

	/* 异常诊断项列表  */
	PenaltyItems []DiagnoseItem `json:"penaltyItems"`

	/* 正常诊断项列表  */
	HealthItems []DiagnoseItem `json:"healthItems"`
}

type DiagnosisResult struct {

	/* Redis组件诊断结果 (Optional) */
	Redis DiagnosisResultItem `json:"redis"`

	/* Redis组件诊断结果 (Optional) */
	Proxy DiagnosisResultItem `json:"proxy"`

	/* Redis组件诊断结果 (Optional) */
	Sentinel DiagnosisResultItem `json:"sentinel"`
}

type DiagnosisResultItem struct {

	/* 是否满足高科用 (Optional) */
	Status string `json:"status"`

	/* 不满足的诊断说明 (Optional) */
	Msg string `json:"msg"`

	/* 所在可用区列表 (Optional) */
	CurrentAZList []string `json:"currentAZList"`
}

type DisableCommands struct {

	/* 命令是否禁用  */
	IsDisable bool `json:"isDisable"`

	/* 命令名称  */
	CommandName string `json:"commandName"`
}

type DisableCommandsInfo struct {

	/* 命令名称 (Optional) */
	CommandName string `json:"commandName"`

	/* 命令禁用时间 (Optional) */
	DisableTime string `json:"disableTime"`
}

type DownloadUrl struct {

	/* 名称  */
	Name string `json:"name"`

	/* 下载链接  */
	Link string `json:"link"`
}

type ExecuteommandResult struct {

	/* 对应执行的命令 (Optional) */
	Command string `json:"command"`

	/* 对应命令执行的结果 (Optional) */
	Result []string `json:"result"`

	/* redis认证后返回的token (Optional) */
	Token string `json:"token"`
}

type ExternalBasicInstance struct {

	/* 集群数量 (Optional) */
	Number int `json:"number"`

	/* 纳管集群实例id (Optional) */
	Instances []string `json:"instances"`
}

type FilterItem struct {

	/*  (Optional) */
	Text string `json:"text"`

	/*  (Optional) */
	Value string `json:"value"`
}

type FlavorDetail struct {

	/* 该规格的CPU核数 (Optional) */
	Cpu int `json:"cpu"`

	/* 该规格的磁盘大小（GB) (Optional) */
	DiskGB int `json:"diskGB"`

	/* 该规格的最大连接数 (Optional) */
	MaxConnection int `json:"maxConnection"`

	/* 该规格的带宽（Mbps) (Optional) */
	BandwidthMbps int `json:"bandwidthMbps"`
}

type HaSwitch struct {

	/* 要切换的分片Id列表, 如全部切换则传空 (Optional) */
	Shards []int `json:"shards"`

	/* 切换到nodeGroup,可以传空会根据targetAZ自动选择ng (ng01、ng02) (Optional) */
	TargetNG string `json:"targetNG"`

	/* 要切换到的目标AZ, 集群模式部署不支持此参数 (Optional) */
	TargetAZ string `json:"targetAZ"`
}

type Health struct {

	/* 实例健康状态 (Optional) */
	Health string `json:"health"`

	/* admin健康状态 (Optional) */
	AdminHealth AdminHealth `json:"adminHealth"`

	/* proxy健康状态 (Optional) */
	ProxyHealth ProxiesHealth `json:"proxyHealth"`

	/* 分片健康状态 (Optional) */
	Shards_health ShardsHealth `json:"shards_health"`

	/* 只读节点健康状态 (Optional) */
	ReadonlyHealth ReadonlyHealth `json:"readonlyHealth"`
}

type HotKeyAnalysisNode struct {

	/* 节点id"  */
	NodeId string `json:"nodeId"`

	/* 节点角色，master/slave  */
	NodeRole string `json:"nodeRole"`

	/* 热key数量  */
	HotKeyNum int `json:"hotKeyNum"`
}

type ImageRelease struct {

	/* Redis实例版本  */
	RedisVersion string `json:"redisVersion"`

	/* Redis组件  */
	Component string `json:"component"`

	/* 镜像Tag  */
	ImageTag string `json:"imageTag"`

	/* 镜像名  */
	ImageName string `json:"imageName"`

	/* 镜像状态  */
	Status string `json:"status"`

	/* 是否是默认镜像  */
	IsDefault bool `json:"isDefault"`

	/* 版本描述  */
	Description string `json:"description"`

	/* 版本创建时间  */
	CreatedTime string `json:"createdTime"`
}

type Instance struct {

	/* 实例ID (Optional) */
	InstanceId string `json:"instanceId"`

	/* 用户PIN (Optional) */
	Pin string `json:"pin"`

	/* 状态值 (Optional) */
	Status int `json:"status"`

	/* 实例创建时间 (Optional) */
	CreateTime string `json:"createTime"`
}

type InstanceClass struct {

	/* 规格代码：redis 2.8与redis 4.0的规格码不同，具体参考 https://docs.jdcloud.com/cn/jcs-for-redis/specifications (Optional) */
	InstanceClass string `json:"instanceClass"`

	/* 规格类型：master-slave表示主从版，cluster表示集群版 (Optional) */
	InstanceType string `json:"instanceType"`

	/* cpu核数 (Optional) */
	Cpu int `json:"cpu"`

	/* 内存总容量（MB） (Optional) */
	MemoryMB int `json:"memoryMB"`

	/* 磁盘总容量（GB） (Optional) */
	DiskGB int `json:"diskGB"`

	/* 最大连接数 (Optional) */
	MaxConnection int `json:"maxConnection"`

	/* 内网带宽（MBps） (Optional) */
	BandwidthMbps int `json:"bandwidthMbps"`
}

type InstanceDiagnose struct {

	/* 实例ID  */
	InstanceId string `json:"instanceId"`

	/* 实例名称 (Optional) */
	InstanceName string `json:"instanceName"`

	/* 是否开启自动诊断  */
	AutoDiagnose bool `json:"autoDiagnose"`

	/* 诊断周期 (Optional) */
	DiagnosePeriod string `json:"diagnosePeriod"`

	/* 诊断时间段 (Optional) */
	DiagnoseTime string `json:"diagnoseTime"`

	/* 最近诊断时间（RFC3339格式） (Optional) */
	LatestDiagnoseTime string `json:"latestDiagnoseTime"`

	/* 最近诊断结果评分（0-100） (Optional) */
	LatestDiagnoseResult int `json:"latestDiagnoseResult"`

	/* 最近诊断摘要 (Optional) */
	LatestDiagnoseSummary string `json:"latestDiagnoseSummary"`

	/* 最近诊断任务ID (Optional) */
	LatestDiagnoseTaskId string `json:"latestDiagnoseTaskId"`
}

type InstanceDomain struct {

	/* 域名 (Optional) */
	DomainName string `json:"domainName"`
}

type InstanceInternalSpec struct {

	/* 实例ID (Optional) */
	InstanceId string `json:"instanceId"`

	/* 实例总内存（GB） (Optional) */
	InstanceMemoryGB int `json:"instanceMemoryGB"`

	/* 实例总内存（MB） (Optional) */
	InstanceMemoryMB int `json:"instanceMemoryMB"`

	/* 内部节点角色列表 (Optional) */
	NodeRoles []NodeRole `json:"nodeRoles"`
}

type InstanceName struct {

	/* 资源id（即实例id）  */
	ResourceId string `json:"resourceId"`

	/* 资源名称（即实例名称）  */
	ResourceName string `json:"resourceName"`

	/* 资源状态：creating表示创建中，running表示运行中，error表示错误，changing表示变更规格中，deleting表示删除中，configuring表示修改参数中，restoring表示备份恢复中 (Optional) */
	ResourceStatus string `json:"resourceStatus"`

	/* service code（redis）  */
	ServiceCode string `json:"serviceCode"`
}

type InstanceSpec struct {

	/* region id (Optional) */
	Region string `json:"region"`

	/* 版本信息列表 (Optional) */
	InstanceVersions []VersionInfo `json:"instanceVersions"`
}

type InstanceVpcIp struct {

	/* 代理列表 (Optional) */
	Proxies []Node `json:"proxies"`

	/* 分片列表 (Optional) */
	Shards []RedisShard `json:"shards"`
}

type InternalInstance struct {

	/* pin (Optional) */
	Pin string `json:"pin"`

	/* region (Optional) */
	Region string `json:"region"`

	/* 实例ID (Optional) */
	InstanceId string `json:"instanceId"`

	/* 实例名称 (Optional) */
	InstanceName string `json:"instanceName"`

	/* 实例类型：master-slave表示主从版，cluster表示集群版 (Optional) */
	InstanceType string `json:"instanceType"`

	/* 实例状态：creating表示创建中，running表示运行中，error表示错误，changing表示变更规格中，deleting表示删除中，configuring表示修改参数中，restoring表示备份恢复中 (Optional) */
	InstanceStatus string `json:"instanceStatus"`

	/* 实例版本：包括2.8、4.0 (Optional) */
	InstanceVersion string `json:"instanceVersion"`

	/* 创建时间（ISO 8601标准的UTC时间，格式为：YYYY-MM-DDTHH:mm:ssZ） (Optional) */
	CreatedTime string `json:"createdTime"`

	/* 所属VPC ID (Optional) */
	VpcId string `json:"vpcId"`

	/* 所属子网ID (Optional) */
	SubnetId string `json:"subnetId"`

	/* 访问域名 (Optional) */
	ConnectionDomain string `json:"connectionDomain"`

	/* 访问端口 (Optional) */
	ConnectionPort int `json:"connectionPort"`

	/* 连接redis实例时，是否需要密码认证，false表示无密码 (Optional) */
	Auth bool `json:"auth"`

	/* 前端app ip (Optional) */
	FrontAppIp string `json:"frontAppIp"`

	/* 实例内部节点ip列表 (Optional) */
	Ips []string `json:"ips"`

	/* 实例内部节点所在宿主机ip列表 (Optional) */
	HostIps []string `json:"hostIps"`
}

type IpNumbers struct {

	/* 没有代理所需的IP数 (Optional) */
	IpNumber int `json:"ipNumber"`

	/* 有代理所需的IP数 (Optional) */
	IpNumberWithProxy int `json:"ipNumberWithProxy"`
}

type Ips struct {

	/* client的ip地址  */
	Ip string `json:"ip"`

	/* clientIp地址下对应的client个数  */
	ClientCount int `json:"clientCount"`
}

type KeyFilter struct {

	/* 按过期时间过滤(ttl)、按空闲时间过滤(idle)  */
	FilterType string `json:"filterType"`

	/* 操作符(eq、gt、lt)  */
	Operator string `json:"operator"`

	/* 操作值  */
	Value int `json:"value"`
}

type KeysDistribution struct {

	/* 过期时间开始，为0表示无过期时间，单位：分钟 (Optional) */
	RangeMin int `json:"rangeMin"`

	/* 过期时间开始，为0表示无过期时间，单位：分钟 (Optional) */
	RangeMax int `json:"rangeMax"`

	/* 统计维度 (Optional) */
	Dimension string `json:"dimension"`

	/* key数量 (Optional) */
	Count int `json:"count"`

	/* key占用内存 (Optional) */
	MemoryUsage int `json:"memoryUsage"`
}

type ListFilterAndSort struct {

	/* 过滤项 map[string][]interface{} (Optional) */
	Filters interface{} `json:"filters"`

	/* 排序项 (Optional) */
	Sorts []string `json:"sorts"`
}

type MetricBucket struct {

	/* 桶名称（如：实例ID、分片ID、代理ID等） (Optional) */
	BucketName string `json:"bucketName"`

	/* 时间范围内最大值 (Optional) */
	Max float32 `json:"max"`

	/* 时间范围内平均值 (Optional) */
	Avg float32 `json:"avg"`

	/* 时间范围内最新值 (Optional) */
	Latest float32 `json:"latest"`

	/* 时间序列点列表 (Optional) */
	Points float32 `json:"points"`
}

type MetricPoint struct {

	/* 采样时间（RFC3339格式） (Optional) */
	Timestamp string `json:"timestamp"`

	/* 指标值 (Optional) */
	Value float32 `json:"value"`
}

type ModifyAccount struct {

	/* 账号名称  */
	AccountName string `json:"accountName"`

	/* 账号密码 (Optional) */
	AccountPassword *string `json:"accountPassword"`

	/* 账号权限。支持RoleReadOnly（只读权限）、RoleReadWrite（读写权限） (Optional) */
	AccountPrivilege *string `json:"accountPrivilege"`

	/* 账号描述 (Optional) */
	AccountDescription *string `json:"accountDescription"`
}

type ModifyHistory struct {

	/* 参数名称 (Optional) */
	ConfigName string `json:"configName"`

	/* 修改前的参数值 (Optional) */
	BeforeConfigValue string `json:"beforeConfigValue"`

	/* 修改后的参数值 (Optional) */
	AfterConfigValue string `json:"afterConfigValue"`

	/* 参数修改状态 (Optional) */
	ModifyStatus string `json:"modifyStatus"`

	/* 参数修改时间 (Optional) */
	ModifyTime string `json:"modifyTime"`
}

type ModuleInfo struct {

	/* module名称  */
	Name string `json:"name"`

	/* module状态  */
	Status string `json:"status"`

	/* module描述  */
	Description string `json:"description"`
}

type Node struct {

	/*  (Optional) */
	Id string `json:"id"`

	/*  (Optional) */
	Ip string `json:"ip"`

	/*  (Optional) */
	Port int `json:"port"`
}

type NodeRole struct {

	/* 节点角色，包括：1）master 主分片节点；2）slave 从分片节点；3）proxy 代理节点；4）admin 管理节点 (Optional) */
	Kind string `json:"kind"`

	/* 节点个数 (Optional) */
	Num int `json:"num"`

	/* 节点规格 (Optional) */
	NodeSpec NodeSpec `json:"nodeSpec"`
}

type NodeSpec struct {

	/* CPU核数 (Optional) */
	CpuCores int `json:"cpuCores"`

	/* 内存大小（GB） (Optional) */
	MemoryGBs int `json:"memoryGBs"`

	/* 内存大小（MB） (Optional) */
	MemoryMBs int `json:"memoryMBs"`

	/* 总磁盘大小（GB） (Optional) */
	TotalDiskGBs int `json:"totalDiskGBs"`

	/* 本地磁盘大小（GB） (Optional) */
	LocalDiskGBs int `json:"localDiskGBs"`

	/* 云盘大小（GB） (Optional) */
	CloudDiskGBs int `json:"cloudDiskGBs"`
}

type OfflineAnalysisTask struct {

	/* 缓存分析的任务ID (Optional) */
	TaskId string `json:"taskId"`

	/* 任务开始时间 (Optional) */
	StartTime string `json:"startTime"`

	/* 任务结束时间 (Optional) */
	EndTime string `json:"endTime"`

	/* 缓存分析任务状态, 只有sucess状态，才能根据taskId查询到结果 (Optional) */
	Status string `json:"status"`
}

type OpsTag struct {

	/* 用于标识资源分类的Tag键 (Optional) */
	Key *string `json:"key"`

	/* 用于标识资源分类的Tag值 (Optional) */
	Value *string `json:"value"`
}

type OrderStatus struct {

	/* 订单总数 (Optional) */
	Total int `json:"total"`

	/* 成功的订单数 (Optional) */
	Success int `json:"success"`

	/* 失败的订单数 (Optional) */
	Fail int `json:"fail"`

	/* 正在处理的订单数 (Optional) */
	InProcess int `json:"inProcess"`

	/* 成功的资源Id (Optional) */
	ResourceIds []string `json:"resourceIds"`
}

type PerformanceDataMsg struct {

	/* 时间 (Optional) */
	Ts string `json:"ts"`

	/* TP999 (Optional) */
	Tp999 int `json:"tp999"`

	/* TP99 (Optional) */
	Tp99 int `json:"tp99"`

	/* TP90 (Optional) */
	Tp90 int `json:"tp90"`

	/* TP50 (Optional) */
	Tp50 int `json:"tp50"`

	/* 最大延时 (Optional) */
	Max int `json:"max"`

	/* 最小延时 (Optional) */
	Min int `json:"min"`

	/* 成功数 (Optional) */
	Success int `json:"success"`

	/* 错误数 (Optional) */
	Error int `json:"error"`

	/* 重定向数 (Optional) */
	Redirection int `json:"redirection"`
}

type ProxiesHealth struct {

	/* red的代理数量 (Optional) */
	RedProxy int `json:"redProxy"`

	/* orange的代理数量 (Optional) */
	OrangeProxy int `json:"orangeProxy"`

	/* yellow的代理数量 (Optional) */
	YellowProxy int `json:"yellowProxy"`

	/* green的代理数量 (Optional) */
	GreenProxy int `json:"greenProxy"`

	/* 探测 redis 成功率 (Optional) */
	ProbeSuccessPercent float32 `json:"probeSuccessPercent"`

	/*  (Optional) */
	UnHealthProxy []ProxyHealth `json:"unHealthProxy"`
}

type Proxy struct {

	/*   */
	Id string `json:"id"`
}

type ProxyHealth struct {

	/* proxy名称 (Optional) */
	Name string `json:"name"`

	/* proxy容器ip (Optional) */
	Ip string `json:"ip"`

	/* proxy容器状态 (Optional) */
	Phase string `json:"phase"`

	/* proxy健康状态 (Optional) */
	Health string `json:"health"`

	/* 探测 redis 成功率 (Optional) */
	ProbeSuccessPercent float32 `json:"probeSuccessPercent"`

	/* proxy网络是否符合预期 (Optional) */
	NetworkExpected bool `json:"networkExpected"`

	/* proxy拓扑是否符合预期 (Optional) */
	TopoExpected bool `json:"topoExpected"`

	/* proxy密码是否符合预期 (Optional) */
	PasswordExpected bool `json:"passwordExpected"`
}

type ProxyInfo struct {

	/* 代理名称 (Optional) */
	Proxy_name string `json:"proxy_name"`

	/* 代理名称 (Optional) */
	Success_rate float32 `json:"success_rate"`

	/* 总请求数 (Optional) */
	Total_req int `json:"total_req"`

	/* 成功请求数 (Optional) */
	Available_req int `json:"available_req"`

	/* 错误信息 (Optional) */
	Errors []string `json:"errors"`

	/* 开始时间 (Optional) */
	Start_time string `json:"start_time"`

	/* 持续时间 (Optional) */
	Duration string `json:"duration"`
}

type ProxyNode struct {

	/* 代理名称 (Optional) */
	Name string `json:"name"`

	/* 代理地址 (Optional) */
	Address string `json:"address"`

	/* 代理可用区 (Optional) */
	Az string `json:"az"`

	/* proxy状态，running/error (Optional) */
	Status string `json:"status"`
}

type ProxyProbeStats struct {

	/* 实例整体成功率 (Optional) */
	Space_success_rate bool `json:"space_success_rate"`

	/* 不同代理的成功率 (Optional) */
	Proxy_success_rate interface{} `json:"proxy_success_rate"`

	/* 状态为running的代理数量 (Optional) */
	Running_proxy int `json:"running_proxy"`

	/* 开始时间 (Optional) */
	Start_time string `json:"start_time"`

	/* 持续时间 (Optional) */
	Duration string `json:"duration"`

	/* 代理详情 (Optional) */
	Proxy_info ProxyInfo `json:"proxy_info"`
}

type ProxyRateFlavor struct {

	/* rate (Optional) */
	Rate int `json:"rate"`

	/* base flavor (Optional) */
	Base_flavor string `json:"base_flavor"`

	/* 磁盘大小 (Optional) */
	Disk int `json:"disk"`

	/* 机型 (Optional) */
	Machines []string `json:"machines"`
}

type ProxySlowLogItem struct {

	/* 命令开始执行时间（Unix epoch 毫秒） (Optional) */
	StartTime int `json:"startTime"`

	/* proxy名称 (Optional) */
	ProxyName string `json:"proxyName"`

	/* 命令 (Optional) */
	Command string `json:"command"`

	/* 涉及的分片ID列表（逗号分隔） (Optional) */
	ShardIds string `json:"shardIds"`

	/* 涉及的redis节点地址 (Optional) */
	Redis_server string `json:"redis_server"`

	/* 客户端IP (Optional) */
	ClientIp string `json:"clientIp"`

	/* DB编号 (Optional) */
	Db int `json:"db"`

	/* 总耗时（微秒） (Optional) */
	TotalLatency int `json:"totalLatency"`

	/* 发送到Redis耗时（微秒） (Optional) */
	SendToRedisLatency int `json:"sendToRedisLatency"`

	/* 从Redis接收耗时（微秒） (Optional) */
	RecvFromRedisLatency int `json:"recvFromRedisLatency"`

	/* 回复客户端耗时（微秒） (Optional) */
	ReplyToClientLatency int `json:"replyToClientLatency"`

	/* 等待命令回复数量 (Optional) */
	WaitCmdReplyCount int `json:"waitCmdReplyCount"`
}

type QuotaInfo struct {

	/* 配额上限 (Optional) */
	Max int `json:"max"`

	/* 已使用 (Optional) */
	Used int `json:"used"`
}

type ReadonlyHealth struct {

	/* red的readonly数量 (Optional) */
	RedReadOnly int `json:"redReadOnly"`

	/* orange的readonly数量 (Optional) */
	OrangeReadOnly int `json:"orangeReadOnly"`

	/* yellow的readonly数量 (Optional) */
	YellowReadOnly int `json:"yellowReadOnly"`

	/* green的readonly数量 (Optional) */
	GreenReadOnly int `json:"greenReadOnly"`

	/*  (Optional) */
	UnHealthReadOnly []RedisNodeHealth `json:"unHealthReadOnly"`
}

type Redis struct {

	/*   */
	Id string `json:"id"`
}

type RedisBigKey struct {

	/* key名称  */
	Name string `json:"name"`

	/* key所在的db号  */
	Db int `json:"db"`

	/* key占用的内存，单位：字节  */
	Size int `json:"size"`
}

type RedisCmd struct {

	/* 命令名称  */
	Name string `json:"name"`

	/* 命令调用次数或命令使用cpu的毫秒数  */
	Data int64 `json:"data"`
}

type RedisHotKey struct {

	/* key名称  */
	Key string `json:"key"`

	/* 统计时间  */
	AccessTime string `json:"accessTime"`

	/* 访问频率  */
	AccessCount int `json:"accessCount"`

	/* key所在的db号 (Optional) */
	Db int `json:"db"`
}

type RedisKey struct {

	/* key名称  */
	Name string `json:"name"`

	/* key所在的db号  */
	Db int `json:"db"`

	/* string类型的key表示字节数，list类型的key表示列表长度，set或zset类型的key表示集合或有序集合的大小、hash类型的key表示字典的大小等等  */
	Size int `json:"size"`

	/* string、list、set、zset、hash五种类型  */
	KeyType string `json:"keyType"`

	/* key访问的频度 (Optional) */
	Frequency int `json:"frequency"`
}

type RedisKeySpaceData struct {

	/* key名称 (Optional) */
	KeyName string `json:"keyName"`

	/* key类型 (Optional) */
	KeyType string `json:"keyType"`

	/* key编码方式 (Optional) */
	Encoding string `json:"encoding"`

	/* key过期时间，空表示没有过期时间 (Optional) */
	ExpireFormat string `json:"expireFormat"`

	/* key内存大小，单位Byte (Optional) */
	MemoryUsage string `json:"memoryUsage"`

	/* 元素个数 (Optional) */
	ItemCount int `json:"itemCount"`

	/* 最大元素长度 (Optional) */
	MaxItemLength int `json:"maxItemLength"`

	/* 平均元素长度 (Optional) */
	AvgItemLength int `json:"avgItemLength"`

	/* 所属分片序号 (Optional) */
	ShardId int `json:"shardId"`

	/* db (Optional) */
	Db int `json:"db"`
}

type RedisNode struct {

	/* 节点名称，唯一标识一个节点  */
	Name string `json:"name"`

	/* 节点分片ID，从0开始  */
	ShardId string `json:"shardId"`

	/* 节点角色，master表示主节点，slave表示从节点 (Optional) */
	Role string `json:"role"`

	/* 节点访问地址 (Optional) */
	Address string `json:"address"`

	/* 节点所属AZ (Optional) */
	Az string `json:"az"`

	/* 节点的node group索引 (Optional) */
	Ng string `json:"ng"`

	/* 节点状态，running表示节点正常，error表示节点异常 (Optional) */
	Status string `json:"status"`

	/* 节点负责的Slot个数 (Optional) */
	Slots int `json:"slots"`

	/* 节点已使用内存，单位Byte (Optional) */
	UsedMemory int64 `json:"usedMemory"`

	/* 节点总内存，单位Byte (Optional) */
	MaxMemory int64 `json:"maxMemory"`
}

type RedisNodeDetail struct {

	/* 节点名称，唯一标识一个节点  */
	Name string `json:"name"`

	/* 节点分片ID，从0开始  */
	ShardId string `json:"shardId"`

	/* 节点角色，master表示主节点，slave表示从节点 (Optional) */
	Role string `json:"role"`

	/* 节点访问地址 (Optional) */
	Address string `json:"address"`

	/* 节点所属AZ (Optional) */
	Az string `json:"az"`

	/* 节点的node group索引 (Optional) */
	Ng string `json:"ng"`

	/* 节点状态，running表示节点正常，error表示节点异常 (Optional) */
	Status string `json:"status"`

	/* 节点负责的Slot个数 (Optional) */
	Slots int `json:"slots"`

	/* 节点已使用内存，单位Byte (Optional) */
	UsedMemory int64 `json:"usedMemory"`

	/* 节点总内存，单位Byte (Optional) */
	MaxMemory int64 `json:"maxMemory"`

	/* 节点的nodeName (Optional) */
	NodeName string `json:"nodeName"`

	/* 节点的重启次数 (Optional) */
	Restart int `json:"restart"`

	/* 节点的启动时长 (Optional) */
	Age int64 `json:"age"`

	/* 节点ready状态 (Optional) */
	Condi string `json:"condi"`

	/* 节点的容器列表 (Optional) */
	Containers []Container `json:"containers"`
}

type RedisNodeHealth struct {

	/* redis名称 (Optional) */
	Name string `json:"name"`

	/* redis容器ip (Optional) */
	Ip string `json:"ip"`

	/* redis角色 (Optional) */
	Role string `json:"role"`

	/* redis负责的槽位 (Optional) */
	Slots string `json:"slots"`

	/* redis最大内存 (Optional) */
	MaxMemory string `json:"maxMemory"`

	/* redis健康状态 (Optional) */
	Health string `json:"health"`

	/* redis角色是否符合预期 (Optional) */
	RoleExpected bool `json:"roleExpected"`

	/* redis槽位是否符合预期 (Optional) */
	SlotsExpected bool `json:"slotsExpected"`

	/* redis maxmemory是否符合预期 (Optional) */
	MaxMemoryExpected bool `json:"maxMemoryExpected"`

	/* redis拓扑是否符合预期 (Optional) */
	TopoExpected bool `json:"topoExpected"`
}

type RedisPredixSpaceData struct {

	/* key前缀 (Optional) */
	Prefix string `json:"prefix"`

	/* key类型 (Optional) */
	KeyType string `json:"keyType"`

	/* key内存大小，单位Byte (Optional) */
	MemoryUsage string `json:"memoryUsage"`

	/* 元素个数 (Optional) */
	ItemCount int `json:"itemCount"`

	/* key个数 (Optional) */
	Count int `json:"count"`
}

type RedisServerLog struct {

	/* 时间 (Optional) */
	CreateTime string `json:"createTime"`

	/* pod名称 (Optional) */
	PodName string `json:"podName"`

	/* 日志信息 (Optional) */
	Message string `json:"message"`
}

type RedisShard struct {

	/* master节点 (Optional) */
	Master Node `json:"master"`

	/* slave节点列表 (Optional) */
	Slaves []Node `json:"slaves"`
}

type RedisType struct {

	/* type名称  */
	Name string `json:"name"`

	/* 当前type的key个数  */
	KeyNumber int64 `json:"keyNumber"`

	/* 当前type的key的内存大小，单位：字节，redis2.8无此项  */
	KeySize int64 `json:"keySize"`

	/* type占比  */
	Ratio float32 `json:"ratio"`
}

type RegionAzVo struct {

	/* 别名 (Optional) */
	Alias string `json:"alias"`

	/* 地域ID (Optional) */
	Region string `json:"region"`

	/* 是否可见(1可见，0不可见) (Optional) */
	Visible int `json:"visible"`

	/* az售卖状态列表 (Optional) */
	AzStatusList []AzSaleStatusVo `json:"azStatusList"`
}

type ReqExtension struct {
}

type RespExtension struct {
}

type SentinelCluster struct {

	/* 哨兵集群名称 (Optional) */
	Name string `json:"name"`

	/* 哨兵集群所在命名空间 (Optional) */
	Namespace string `json:"namespace"`

	/* 哨兵集群所在可用区列表 (Optional) */
	AzList []string `json:"azList"`

	/* sentinel集群的Chart版本 (Optional) */
	ChartVersion string `json:"chartVersion"`

	/* sentinel集群所在集群ID (Optional) */
	ClusterId string `json:"clusterId"`
}

type SentinelNode struct {

	/* 哨兵名称 (Optional) */
	Name string `json:"name"`

	/* 哨兵地址 (Optional) */
	Address string `json:"address"`

	/* 哨兵可用区 (Optional) */
	Az string `json:"az"`

	/* sentinel状态，running/error (Optional) */
	Status string `json:"status"`
}

type Shard struct {

	/*   */
	Id string `json:"id"`
}

type ShardHealth struct {

	/* redis分片名称 (Optional) */
	Name string `json:"name"`

	/* 分片ID (Optional) */
	ShardId int `json:"shardId"`

	/* proxy健康状态 (Optional) */
	Health string `json:"health"`

	/* 分片master健康状态 (Optional) */
	MasterHealth RedisNodeHealth `json:"masterHealth"`

	/* 分片slave健康状态 (Optional) */
	SlaveHealth RedisNodeHealth `json:"slaveHealth"`
}

type ShardInfo struct {

	/* master信息 (Optional) */
	Master RedisNode `json:"master"`

	/* replica信息 (Optional) */
	Replicas []RedisNode `json:"replicas"`
}

type ShardSpec struct {

	/* 单分片规格代码，自定义分片集群实例才需要，标准版不需要 (Optional) */
	ShardClass string `json:"shardClass"`

	/* 单分片CPU核数 (Optional) */
	Cpu int `json:"cpu"`

	/* 单分片内存大小（GB） (Optional) */
	MemoryGB int `json:"memoryGB"`

	/* 单分片内存大小（MB） (Optional) */
	MemoryMB int `json:"memoryMB"`

	/* 单分片磁盘大小（GB） (Optional) */
	DiskGB int `json:"diskGB"`

	/* 单分片最大连接数 (Optional) */
	MaxConnection int `json:"maxConnection"`

	/* 单分片带宽（Mbps） (Optional) */
	BandwidthMbps int `json:"bandwidthMbps"`

	/* 支持的分片数列表 (Optional) */
	ShardNumberList []int `json:"shardNumberList"`
}

type ShardsHealth struct {

	/* red的分片数量 (Optional) */
	RedShards int `json:"redShards"`

	/* orange的分片数量 (Optional) */
	OrangeShards int `json:"orangeShards"`

	/* yellow的分片数量 (Optional) */
	YellowShards int `json:"yellowShards"`

	/* green的分片数量 (Optional) */
	GreenShards int `json:"greenShards"`

	/*  (Optional) */
	UnHealthShards []ShardHealth `json:"unHealthShards"`
}

type SlowLog struct {

	/* 命令  */
	Command string `json:"command"`

	/* 命令开始执行时间（ISO 8601标准的UTC时间，格式为：YYYY-MM-DDTHH:mm:ssZ）  */
	StartTime string `json:"startTime"`

	/* 命令执行时长（带单位）  */
	ExecutionTime string `json:"executionTime"`

	/* 执行命令的分片id (Optional) */
	ShardId string `json:"shardId"`

	/* client的地址，包括ip和端口号  */
	ClientAddr string `json:"clientAddr"`

	/* client名称，无则为空  */
	ClientName string `json:"clientName"`
}

type SpecInfo struct {

	/* 内存大小（GB） (Optional) */
	MemoryGB int `json:"memoryGB"`

	/* 内存大小（MB） (Optional) */
	MemoryMB int `json:"memoryMB"`

	/* 实例规格，标准版不为空，4.0 自定义分片集群版规格为空，具体规格参考单分片规格 (Optional) */
	InstanceClass string `json:"instanceClass"`

	/* 实例CPU核数，0表示自定义分片集群版规格，CPU核数由分片数变化 (Optional) */
	Cpu int `json:"cpu"`

	/* 实例磁盘大小（GB)，0表示自定义分片集群版规格，磁盘大小由分片数变化 (Optional) */
	DiskGB int `json:"diskGB"`

	/* 最大连接数，0表示自定义分片集群版规格，最大连接数由分片数变化 (Optional) */
	MaxConnection int `json:"maxConnection"`

	/* 带宽（Mbps)，0表示自定义分片集群版规格，带宽由分片数变化 (Optional) */
	BandwidthMbps int `json:"bandwidthMbps"`

	/* 需要的IP数，0表示自定义分片集群版规格，IP数由分片数变化 (Optional) */
	IpNumber int `json:"ipNumber"`

	/* 实例的分片列表信息，redis 2.8标准版、集群版以及redis 4.0标准版没有分片列表信息 (Optional) */
	Shard ShardInfo `json:"shard"`

	/* az列表 (Optional) */
	Azs []string `json:"azs"`
}

type Tag struct {

	/* 标签的键 (Optional) */
	Key *string `json:"key"`

	/* 标签的值 (Optional) */
	Value *string `json:"value"`
}

type TaskChangeDetail struct {

	/* 变更项名称 (Optional) */
	Name string `json:"name"`

	/* 变更前的值 (Optional) */
	Before string `json:"before"`

	/* 变更后的值 (Optional) */
	After string `json:"after"`
}

type TaskInfo struct {

	/* 任务id (Optional) */
	TaskId string `json:"taskId"`

	/* 实例id (Optional) */
	InstanceId string `json:"instanceId"`

	/* null (Optional) */
	TaskType int `json:"taskType"`

	/* 任务类型中文描述 (Optional) */
	TaskTypeCn string `json:"taskTypeCn"`

	/* 任务状态，可以为init(初始化)、running（执行中）、fail（失败）、success（完成）、manual_stop（停止任务）、rollback（回滚中）、rollback_fail（回滚失败）、rollback_finish（回滚结束） (Optional) */
	TaskStatus string `json:"taskStatus"`

	/* 任务开始时间 (Optional) */
	StartTime string `json:"startTime"`

	/* 任务结束时间 (Optional) */
	EndTime string `json:"endTime"`

	/* 地域 (Optional) */
	RegionId string `json:"regionId"`

	/* 任务是否支持被打断 (Optional) */
	IsSupportInterruptTask bool `json:"isSupportInterruptTask"`

	/* 任务执行时间段的开始时间 (Optional) */
	MaintenanceStartTime string `json:"maintenanceStartTime"`

	/* 任务执行时间段的结束时间 (Optional) */
	MaintenanceEndTime string `json:"maintenanceEndTime"`

	/* 任务预计执行时间 (Optional) */
	EstimatedExecutionTime string `json:"estimatedExecutionTime"`

	/* 任务实际执行时间 (Optional) */
	ExecutionTime string `json:"executionTime"`
}

type TaskProgress struct {

	/* 任务类型：resize表示变配，同一时刻只能有一个变配任务 (Optional) */
	TaskType string `json:"taskType"`

	/* 任务id (Optional) */
	TaskId string `json:"taskId"`

	/* 任务状态：init表示初始化，running表示运行中，success表示成功，fail表示失败 (Optional) */
	TaskStatus string `json:"taskStatus"`

	/* 任务执行百分比 (Optional) */
	ProgressPercent int `json:"progressPercent"`

	/* 执行时长（单位：秒） (Optional) */
	ElapsedTimeSecond int `json:"elapsedTimeSecond"`

	/* 启动时间（ISO 8601标准的UTC时间，格式为：YYYY-MM-DDTHH:mm:ssZ） (Optional) */
	StartTime string `json:"startTime"`
}

type TaskResult struct {

	/* 任务结果信息 (Optional) */
	Result string `json:"result"`

	/* 任务错误信息 (Optional) */
	ErrorInfo string `json:"errorInfo"`

	/* 任务步骤详情 (Optional) */
	StepDetails []TaskStepDetail `json:"stepDetails"`

	/* 任务变更详情 (Optional) */
	ChangeDetails []TaskChangeDetail `json:"changeDetails"`
}

type TaskStepDetail struct {

	/* 步骤名称 (Optional) */
	StepName string `json:"stepName"`

	/* 步骤状态 (Optional) */
	Status string `json:"status"`

	/* 步骤开始时间 (Optional) */
	StartTime string `json:"startTime"`

	/* 步骤结束时间 (Optional) */
	EndTime string `json:"endTime"`
}

type TaskType struct {

	/* 任务类型ID (Optional) */
	Id int `json:"id"`

	/* 任务类型名称 (Optional) */
	Name string `json:"name"`

	/* 任务类型中文名称 (Optional) */
	CnName string `json:"cnName"`
}

type Tasks struct {

	/* 任务ID (Optional) */
	TaskId string `json:"taskId"`

	/* 任务开始时间 (Optional) */
	StartTime string `json:"startTime"`
}

type TopoInfo struct {

	/* 实例ID (Optional) */
	CacheInstanceId string `json:"cacheInstanceId"`

	/* 实例总内存 (Optional) */
	TotalMemory int64 `json:"totalMemory"`

	/* 代理列表 (Optional) */
	ProxyInfo []RedisNode `json:"proxyInfo"`

	/* 节点列表 (Optional) */
	ShardInfo []ShardInfo `json:"shardInfo"`
}

type TypeInfo struct {

	/* 实例类型：目前支持标准版（master-slave）、集群版（cluster） (Optional) */
	InstanceType string `json:"instanceType"`

	/* 规格列表 (Optional) */
	Specs []SpecInfo `json:"specs"`
}

type UpdateConfigTemplate struct {

	/* 模板名称 (Optional) */
	Name string `json:"name"`

	/* 模板描述 (Optional) */
	Description string `json:"description"`

	/* 配置项键值对 (Optional) */
	Val interface{} `json:"val"`
}

type UserDiagnoseTaskInfo struct {

	/* 任务ID  */
	TaskId string `json:"taskId"`

	/* 任务类型（manual-手动，auto-自动）  */
	Type string `json:"type"`

	/* 任务状态  */
	Status string `json:"status"`

	/* 报告生成时间（RFC3339格式）  */
	GenerationTime string `json:"generationTime"`

	/* 诊断开始时间（RFC3339格式）  */
	StartTime string `json:"startTime"`

	/* 诊断结束时间（RFC3339格式） (Optional) */
	EndTime string `json:"endTime"`

	/* 健康评分（0-100）  */
	Score int `json:"score"`
}

type VersionInfo struct {

	/* redis引擎版本：目前支持2.8、4.0 (Optional) */
	RedisVersion string `json:"redisVersion"`

	/* 类型信息列表 (Optional) */
	InstanceTypes []TypeInfo `json:"instanceTypes"`
}

type WhiteList struct {

	/* 白名单名称 (Optional) */
	Name string `json:"name"`

	/* IP或IP段，不同的IP/IP段之间用英文逗号分隔，例如0.0.0.0/0,192.168.0.10 (Optional) */
	Ips string `json:"ips"`
}