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

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

type AvailableFlavor struct {

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

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

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

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

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

type AvailableMemorySpec struct {

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

	/* 是否售罄 (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"`
}

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"`
}

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

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

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 string `json:"stringTypeNum"`

	/* List类型大key数量 (Optional) */
	ListTypeNum string `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"`

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

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

	/* 连接实例时，是否需要密码认证，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"`
}

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"`
}

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 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"`
}

type CpuArchInfo struct {

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

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

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 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 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 HotKeyAnalysisNode struct {

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

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

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

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 InstanceDomain struct {

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

type InstanceInternalSpec struct {

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

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

	/* 内部节点角色列表 (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 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 ModifyAccount struct {

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

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

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

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

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

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

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

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

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 Proxy struct {

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

type QuotaInfo struct {

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

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

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

	/* 节点状态，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 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 Shard struct {

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

type ShardInfo struct {

	/* 默认分片数 (Optional) */
	DefaultShardNumber int `json:"defaultShardNumber"`

	/* 默认单分片规格代码 (Optional) */
	DefaultShardClass string `json:"defaultShardClass"`

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

	/* 需要的IP数列表 (Optional) */
	IpNumberList []int `json:"ipNumberList"`
}

type ShardSpec struct {

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

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

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

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

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

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

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

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"`
}

type SpecInfo struct {

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

	/* 实例规格，标准版不为空，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 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 TypeInfo struct {

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

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

type VersionInfo struct {

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

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