ctgkafka

type Apis struct {
	CtgkafkaTopicQueryV3Api                *CtgkafkaTopicQueryV3Api
	CtgkafkaCreatePostPayOrderApi          *CtgkafkaCreatePostPayOrderApi
	CtgkafkaCreateOrderApi                 *CtgkafkaCreateOrderApi
	CtgkafkaSpecExtendApi                  *CtgkafkaSpecExtendApi
	CtgkafkaTransChargeTypeV3Api           *CtgkafkaTransChargeTypeV3Api
	CtgkafkaUnsubscribeInstV3Api           *CtgkafkaUnsubscribeInstV3Api
	CtgkafkaInstQueryApi                   *CtgkafkaInstQueryApi
	CtgkafkaNodeStatusV3Api                *CtgkafkaNodeStatusV3Api
	CtgkafkaInstancesModifyNameV3Api       *CtgkafkaInstancesModifyNameV3Api
	CtgkafkaModifyInstanceConfigApi        *CtgkafkaModifyInstanceConfigApi
	CtgkafkaTopicStatusV3Api               *CtgkafkaTopicStatusV3Api
	CtgkafkaTopicModifyremarkV3Api         *CtgkafkaTopicModifyremarkV3Api
	CtgkafkaModifypartitionNumV3Api        *CtgkafkaModifypartitionNumV3Api
	CtgkafkaTopicDeleteV3Api               *CtgkafkaTopicDeleteV3Api
	CtgkafkaConsumerGroupCreateV3Api       *CtgkafkaConsumerGroupCreateV3Api
	CtgkafkaConsumerGroupQueryV3Api        *CtgkafkaConsumerGroupQueryV3Api
	CtgkafkaConsumerGroupStatusV3Api       *CtgkafkaConsumerGroupStatusV3Api
	CtgkafkaConsumerGroupInstancesV3Api    *CtgkafkaConsumerGroupInstancesV3Api
	CtgkafkaSelectedTopicsV3Api            *CtgkafkaSelectedTopicsV3Api
	CtgkafkaConsumerGroupUpdatetopicsV3Api *CtgkafkaConsumerGroupUpdatetopicsV3Api
	CtgkafkaConsumerGroupResetV3Api        *CtgkafkaConsumerGroupResetV3Api
	CtgkafkaConsumerGroupDeleteV3Api       *CtgkafkaConsumerGroupDeleteV3Api
	CtgkafkaAclAddV3Api                    *CtgkafkaAclAddV3Api
	CtgkafkaAclQueryV3Api                  *CtgkafkaAclQueryV3Api
	CtgkafkaAclDeleteV3Api                 *CtgkafkaAclDeleteV3Api
	CtgkafkaSaslUserCreateV3Api            *CtgkafkaSaslUserCreateV3Api
	CtgkafkaSaslUserQueryV3Api             *CtgkafkaSaslUserQueryV3Api
	CtgkafkaSaslUserDeleteV3Api            *CtgkafkaSaslUserDeleteV3Api
	CtgkafkaQueryMessageByOffsetV3Api      *CtgkafkaQueryMessageByOffsetV3Api
	CtgkafkaQueryMessageByTimestampV3Api   *CtgkafkaQueryMessageByTimestampV3Api
	CtgkafkaResourceTagAddtagV3Api         *CtgkafkaResourceTagAddtagV3Api
	CtgkafkaListTagV3Api                   *CtgkafkaListTagV3Api
	CtgkafkaTagResourceV3Api               *CtgkafkaTagResourceV3Api
	CtgkafkaListResourceV3Api              *CtgkafkaListResourceV3Api
	CtgkafkaUnTagResourceV3Api             *CtgkafkaUnTagResourceV3Api
	CtgkafkaTopicCreateV3Api               *CtgkafkaTopicCreateV3Api
	CtgkafkaDiskExtendApi                  *CtgkafkaDiskExtendApi
	CtgkafkaDiskShrinkApi                  *CtgkafkaDiskShrinkApi
	CtgkafkaNodeExtendApi                  *CtgkafkaNodeExtendApi
	CtgkafkaNodeShrinkApi                  *CtgkafkaNodeShrinkApi
	CtgkafkaSpecShrinkApi                  *CtgkafkaSpecShrinkApi
	CtgkafkaUpgradeInstanceVersionV3Api    *CtgkafkaUpgradeInstanceVersionV3Api
	CtgkafkaInstancesRestartV3Api          *CtgkafkaInstancesRestartV3Api
	CtgkafkaMirrorTaskApi                  *CtgkafkaMirrorTaskApi
	CtgkafkaChangeAzApi                    *CtgkafkaChangeAzApi
	CtgkafkaProdDetailApi                  *CtgkafkaProdDetailApi
	CtgkafkaCanExpandProdApi               *CtgkafkaCanExpandProdApi
	CtgkafkaQueryCanUpdateVersionV3Api     *CtgkafkaQueryCanUpdateVersionV3Api
	CtgkafkaPageQueryFloatingipsApi        *CtgkafkaPageQueryFloatingipsApi
	CtgkafkaGetInstanceConfigApi           *CtgkafkaGetInstanceConfigApi
	CtgkafkaUpdateInstanceConfigApi        *CtgkafkaUpdateInstanceConfigApi
	CtgkafkaSetAcrossVpcInfoApi            *CtgkafkaSetAcrossVpcInfoApi
	CtgkafkaBindElasticIpApi               *CtgkafkaBindElasticIpApi
	CtgkafkaUnbindElasticIpApi             *CtgkafkaUnbindElasticIpApi
	CtgkafkaEnableAutoReassignApi          *CtgkafkaEnableAutoReassignApi
	CtgkafkaElasticBandwidthApi            *CtgkafkaElasticBandwidthApi
	CtgkafkaGetTopicDetailsApi             *CtgkafkaGetTopicDetailsApi
	CtgkafkaEndMessageApi                  *CtgkafkaEndMessageApi
	CtgkafkaBeginningMessageApi            *CtgkafkaBeginningMessageApi
	CtgkafkaQueryProducersApi              *CtgkafkaQueryProducersApi
	CtgkafkaTopicDiskusageApi              *CtgkafkaTopicDiskusageApi
	CtgkafkaUpdateTopicApi                 *CtgkafkaUpdateTopicApi
	CtgkafkaReassignmentsApi               *CtgkafkaReassignmentsApi
	CtgkafkaProduceApi                     *CtgkafkaProduceApi
	CtgkafkaTopicBatchDeleteApi            *CtgkafkaTopicBatchDeleteApi
	CtgkafkaConsumerGroupUpdateApi         *CtgkafkaConsumerGroupUpdateApi
	CtgkafkaConsumerGroupBatchDeleteApi    *CtgkafkaConsumerGroupBatchDeleteApi
	CtgkafkaGetAuthorityApi                *CtgkafkaGetAuthorityApi
	CtgkafkaUserUpdateApi                  *CtgkafkaUserUpdateApi
	CtgkafkaAddAuthorityApi                *CtgkafkaAddAuthorityApi
	CtgkafkaQueryMessageApi                *CtgkafkaQueryMessageApi
	CtgkafkaMonitorMetricsV3Api            *CtgkafkaMonitorMetricsV3Api
	CtgkafkaQuotaBrokerQueryApi            *CtgkafkaQuotaBrokerQueryApi
	CtgkafkaQuotaBrokerDeleteApi           *CtgkafkaQuotaBrokerDeleteApi
	CtgkafkaQuotaBrokerUpdateApi           *CtgkafkaQuotaBrokerUpdateApi
	CtgkafkaQuotaBrokerCreateApi           *CtgkafkaQuotaBrokerCreateApi
	CtgkafkaQuotaTopicListApi              *CtgkafkaQuotaTopicListApi
	CtgkafkaQuotaTopicDeleteApi            *CtgkafkaQuotaTopicDeleteApi
	CtgkafkaQuotaTopicUpdateApi            *CtgkafkaQuotaTopicUpdateApi
	CtgkafkaQuotaTopicCreateApi            *CtgkafkaQuotaTopicCreateApi
	CtgkafkaQuotaClientListApi             *CtgkafkaQuotaClientListApi
	CtgkafkaQuotaClientDeleteApi           *CtgkafkaQuotaClientDeleteApi
	CtgkafkaQuotaClientUpdateApi           *CtgkafkaQuotaClientUpdateApi
	CtgkafkaQuotaClientCreateApi           *CtgkafkaQuotaClientCreateApi
	CtgkafkaChaosQueryReqMsgApi            *CtgkafkaChaosQueryReqMsgApi
	CtgkafkaChaosCancelApi                 *CtgkafkaChaosCancelApi
	CtgkafkaChaosInjectApi                 *CtgkafkaChaosInjectApi
	CtgkafkaChaosListApi                   *CtgkafkaChaosListApi
	CtgkafkaDeleteAuthorityApi             *CtgkafkaDeleteAuthorityApi
	CtgkafkaInstanceDeleteV3Api            *CtgkafkaInstanceDeleteV3Api
}

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

type CtgkafkaAclAddV3Request struct {
	RegionId      string `json:"regionId,omitempty"`      /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	Username      string `json:"username,omitempty"`      /*  SASL用户名称。  */
	ProdInstId    string `json:"prodInstId,omitempty"`    /*  实例ID。  */
	ResourceType  string `json:"resourceType,omitempty"`  /*  资源类型，可选值：<br><li>TOPIC：主题资源<br><li>GROUP：消费组资源  */
	ResourceName  string `json:"resourceName,omitempty"`  /*  资源名称。  */
	OperationType string `json:"operationType,omitempty"` /*  操作类型，资源类型为TOPIC时必填，可选值：<br><li>READ：读权限<br><li>WRITE：写权限  */
}

type CtgkafkaAclAddV3Response struct {
	StatusCode string                             `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                             `json:"message,omitempty"`    /*  提示信息。  */
	ReturnObj  *CtgkafkaAclAddV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                             `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaAclAddV3ReturnObjResponse struct {
	Data string `json:"data,omitempty"` /*  返回数据。  */
}

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

type CtgkafkaAclDeleteV3Request struct {
	RegionId      string `json:"regionId,omitempty"`      /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	Username      string `json:"username,omitempty"`      /*  SASL用户名称。  */
	ProdInstId    string `json:"prodInstId,omitempty"`    /*  实例ID。  */
	ResourceType  string `json:"resourceType,omitempty"`  /*  资源类型，可选值：<br><li>TOPIC：主题资源<br><li>GROUP：消费组资源  */
	ResourceName  string `json:"resourceName,omitempty"`  /*  资源名称。  */
	OperationType string `json:"operationType,omitempty"` /*  操作类型，资源类型为TOPIC时必填，可选值：<br><li>READ：读权限<br><li>WRITE：写权限  */
}

type CtgkafkaAclDeleteV3Response struct {
	StatusCode string                                `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaAclDeleteV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaAclDeleteV3ReturnObjResponse struct {
	Data string `json:"data,omitempty"` /*  返回数据。  */
}

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

type CtgkafkaAclQueryV3Request struct {
	RegionId     string `json:"regionId,omitempty"`     /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId   string `json:"prodInstId,omitempty"`   /*  实例ID。  */
	Username     string `json:"username,omitempty"`     /*  用户名称。  */
	ResourceType string `json:"resourceType,omitempty"` /*  资源类型，可选值：<br><li>TOPIC：主题资源<br><li>GROUP：消费组资源，云原生引擎无GROUP资源  */
	ResourceName string `json:"resourceName,omitempty"` /*  资源名称。  */
}

type CtgkafkaAclQueryV3Response struct {
	StatusCode string                               `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                               `json:"message,omitempty"`    /*  提示信息。  */
	ReturnObj  *CtgkafkaAclQueryV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                               `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaAclQueryV3ReturnObjDataEntryDataResponse struct {
	Principal string `json:"principal,omitempty"` /*  权限主体。  */
	Host      string `json:"host,omitempty"`      /*  拥有权限的主机地址。  */
}

type CtgkafkaAclQueryV3ReturnObjDataEntryResponse struct {
	Data *CtgkafkaAclQueryV3ReturnObjDataEntryDataResponse `json:"data"` /*  资源ACL条目。  */
}

type CtgkafkaAclQueryV3ReturnObjDataResourceResponse struct {
	ResourceType string `json:"resourceType,omitempty"` /*  资源类型。  */
	Name         string `json:"name,omitempty"`         /*  资源名称。  */
}

type CtgkafkaAclQueryV3ReturnObjDataResponse struct {
	Resource *CtgkafkaAclQueryV3ReturnObjDataResourceResponse `json:"resource"` /*  资源信息。  */
	Entry    *CtgkafkaAclQueryV3ReturnObjDataEntryResponse    `json:"entry"`    /*  资源条目信息。  */
}

type CtgkafkaAclQueryV3ReturnObjResponse struct {
	Data []*CtgkafkaAclQueryV3ReturnObjDataResponse `json:"data"` /*  返回数据。  */
}

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

type CtgkafkaAddAuthorityRequest struct {
	RegionId          string   `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId        string   `json:"prodInstId,omitempty"` /*  实例ID。  */
	Username          string   `json:"username,omitempty"`   /*  用户名称。  */
	AddWriteAuthority []string `json:"addWriteAuthority"`    /*  要增加生产权限的主题名称列表。与addReadAuthority至少一个不为空。  */
	AddReadAuthority  []string `json:"addReadAuthority"`     /*  要增加消费权限的主题名称列表。与addWriteAuthority至少一个不为空。  */
}

type CtgkafkaAddAuthorityResponse struct {
	StatusCode string                                 `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                 `json:"message,omitempty"`    /*  提示信息。  */
	ReturnObj  *CtgkafkaAddAuthorityReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                 `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaAddAuthorityReturnObjResponse struct {
	Data string `json:"data,omitempty"` /*  返回创建描述。  */
}

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

type CtgkafkaBeginningMessageRequest struct {
	RegionId    string `json:"regionId,omitempty"`    /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId  string `json:"prodInstId,omitempty"`  /*  实例ID。  */
	TopicName   string `json:"topicName,omitempty"`   /*  主题名称。  */
	PartitionId int32  `json:"partitionId,omitempty"` /*  主题分区ID。  */
}

type CtgkafkaBeginningMessageResponse struct {
	StatusCode int32                                      `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900。  */
	Message    string                                     `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaBeginningMessageReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                     `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaBeginningMessageReturnObjDataResponse struct {
	TopicName string `json:"topicName,omitempty"` /*  主题名称。  */
	Partition int32  `json:"partition,omitempty"` /*  分区ID。  */
	Offset    int64  `json:"offset,omitempty"`    /*  最新消息偏移量。  */
	TimeStamp int64  `json:"timeStamp,omitempty"` /*  最新消息时间戳。  */
}

type CtgkafkaBeginningMessageReturnObjResponse struct {
	Data []*CtgkafkaBeginningMessageReturnObjDataResponse `json:"data"` /*  主题信息。  */
}

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

type CtgkafkaBindElasticIpRequest struct {
	RegionId       string `json:"regionId,omitempty"`       /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	PaasInstanceId string `json:"paasInstanceId,omitempty"` /*  实例ID。  */
	Ip             string `json:"ip,omitempty"`             /*  节点的IP地址，可以通过查</span> <a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=48&api=7382&data=83&isNormal=1&vid=330">查询实例</a> 获取具体节点IP地址。  */
	ElasticIp      string `json:"elasticIp,omitempty"`      /*  绑定的弹性IP。  */
}

type CtgkafkaBindElasticIpResponse struct {
	StatusCode string                                  `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                  `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaBindElasticIpReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                  `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaBindElasticIpReturnObjDataResponse struct{}

type CtgkafkaBindElasticIpReturnObjResponse struct {
	Data *CtgkafkaBindElasticIpReturnObjDataResponse `json:"data"` /*  返回数据。  */
}

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

type CtgkafkaCanExpandProdRequest struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID，如果填入，则返回指定实例信息  */
}

type CtgkafkaCanExpandProdResponse struct {
	StatusCode string                                  `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"  */
	Message    string                                  `json:"message,omitempty"`    /*  描述状态  */
	ReturnObj  *CtgkafkaCanExpandProdReturnObjResponse `json:"returnObj"`            /*  返回对象。此参数所包含的参数请见“响应示例”里面的注释  */
	Error      string                                  `json:"error,omitempty"`      /*  错误码，描述错误信息  */
}

type CtgkafkaCanExpandProdReturnObjResponse struct{}

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

type CtgkafkaChangeAzRequest struct {
	RegionId   string   `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string   `json:"prodInstId,omitempty"` /*  实例ID。  */
	AzInfoList []string `json:"azInfoList"`           /*  可用区信息。只能填一个（单可用区）或三个（多可用区），可用区信息可调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5855&data=87&isNormal=1&vid=81">资源池可用区查询</a>API接口查询。  */
}

type CtgkafkaChangeAzResponse struct {
	StatusCode string                             `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                             `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaChangeAzReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                             `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaChangeAzReturnObjResponse struct {
	Data string `json:"data,omitempty"` /*  返回数据。  */
}

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

type CtgkafkaChaosCancelRequest struct {
	RegionId     string `json:"regionId,omitempty"`     /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId   string `json:"prodInstId,omitempty"`   /*  实例ID。  */
	ExperimentId string `json:"experimentId,omitempty"` /*  故障演练ID。  */
}

type CtgkafkaChaosCancelResponse struct {
	StatusCode int32                                 `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900。  */
	Message    string                                `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaChaosCancelReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaChaosCancelReturnObjResponse struct {
	Data string `json:"data,omitempty"` /*  返回数据。  */
}

type CtgkafkaChaosInjectActionParameterRequest struct {
	CpuPercent   int32  `json:"cpuPercent,omitempty"`   /*  演练CPU负载率，取值范围[1, 100]，当actionCode=cpu-fullload时需传入。  */
	Duration     int32  `json:"duration,omitempty"`     /*  故障持续时间，单位秒，取值范围[60, 3600]，当actionCode=disk-burn或cpu-fullload时需传入。  */
	NodeKillType int32  `json:"nodeKillType,omitempty"` /*  节点宕机模式，当actionCode=node-shutdown时需传入。<br><li>0：随机节点宕机，随机宕机1个节点<br><li>1：随机可用区宕机，宕机1个随机可用区下所有节点<br><li>2：指定节点宕机<br><li>3：指定可用区宕机，宕机该可用区下所有节点</li>  */
	EcsId        string `json:"ecsId,omitempty"`        /*  指定节点宕机的节点ID，当nodeKillType=2时需传入。<br><span style="background-color: rgb(73, 204, 144);color: rgb(255,255,255);padding: 2px; margin:2px">查</span> <a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=48&api=7382&data=83&isNormal=1&vid=330">实例信息</a> 查询对应实例下nodeList的ecsId属性值。  */
	AzName       string `json:"azName,omitempty"`       /*  指定可用区宕机的可用区名称，当nodeKillType=3时需传入。<br><span style="background-color: rgb(73, 204, 144);color: rgb(255,255,255);padding: 2px; margin:2px">查</span> <a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=48&api=7382&data=83&isNormal=1&vid=33">实例信息</a> 查询实例下nodeList的azName属性值获取实例所在可用区列表。  */
}

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

type CtgkafkaChaosInjectRequest struct {
	RegionId        string                                     `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId      string                                     `json:"prodInstId,omitempty"` /*  实例ID。  */
	ActionCode      string                                     `json:"actionCode,omitempty"` /*  故障任务类型。<br><li>node-shutdown：节点关机，Broker宕机，请勿频繁进行开关机演练，可能会因Kafka监控数据不全导致演练失败(若出现失败，可在15分钟之后重试)。<br><li>cpu-fullload：CPU高负载，Broker CPU高负载，该故障动作会随机向Kafka实例的一个Broker节点注入CPU高负载故障，建议实例上有真实消息生产与消费流量，主题分区数大于3。<br><li>disk-burn：磁盘IO高负载，Broker 磁盘I0高负载，该故障动作会随机向Kafka实例的一个Broker节点注入磁盘I0高负载故障，建议实例上有真实消息生产与消费流量，主题分区数大于3。  */
	ActionParameter *CtgkafkaChaosInjectActionParameterRequest `json:"actionParameter"`      /*  故障注入参数。  */
}

type CtgkafkaChaosInjectResponse struct {
	StatusCode int32                                 `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900。  */
	Message    string                                `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaChaosInjectReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaChaosInjectReturnObjResponse struct {
	ExperimentId string `json:"experimentId,omitempty"` /*  故障演练ID。  */
	TaskId       string `json:"taskId,omitempty"`       /*  故障演练任务ID。  */
}

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

type CtgkafkaChaosListRequest struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
	PageNum    int32  `json:"pageNum,omitempty"`    /*  分页中的页数，默认1，范围1-40000。  */
	PageSize   int32  `json:"pageSize,omitempty"`   /*  分页中的每页大小，默认10。  */
}

type CtgkafkaChaosListResponse struct {
	StatusCode int32                               `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900。  */
	Message    string                              `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaChaosListReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                              `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaChaosListReturnObjDataActionActionParameterResponse struct {
	Code  string `json:"code,omitempty"`  /*  属性编码。  */
	Value string `json:"value,omitempty"` /*  属性值。  */
}

type CtgkafkaChaosListReturnObjDataActionResponse struct {
	ActionCode      string                                                         `json:"actionCode,omitempty"`  /*  故障任务类型。<br><li>node-shutdown：节点关机<br><li>cpu-fullload：CPU高负载<br><li>disk-burn：磁盘IO高负载  */
	ActionScope     string                                                         `json:"actionScope,omitempty"` /*  故障范围。<br><li>host：主机<br><li>cluster：集群  */
	ActionParameter []*CtgkafkaChaosListReturnObjDataActionActionParameterResponse `json:"actionParameter"`       /*  任务参数配置。  */
}

type CtgkafkaChaosListReturnObjDataInjectActionInstanceActionParameterResponse struct {
	Code  string `json:"code,omitempty"`  /*  属性编码。  */
	Value string `json:"value,omitempty"` /*  属性值。  */
}

type CtgkafkaChaosListReturnObjDataInjectActionInstanceLogsResponse struct {
	StepName    string `json:"stepName,omitempty"`    /*  步骤名称。  */
	SubStepName string `json:"subStepName,omitempty"` /*  子步骤名称。  */
	LogLevel    string `json:"logLevel,omitempty"`    /*  日志级别。<br><li>INFO<br><li>ERROR  */
	StepResult  string `json:"stepResult,omitempty"`  /*  步骤结果。<br><li>PROCESSING：处理中<br><li>SUCCESS：成功<br><li>ERROR：错误<br><li>RETRYING：重试中  */
	Msg         string `json:"msg,omitempty"`         /*  日志内容。  */
	LogTime     string `json:"logTime,omitempty"`     /*  日志时间。  */
}

type CtgkafkaChaosListReturnObjDataInjectActionInstanceResponse struct {
	TaskId          string                                                                       `json:"taskId,omitempty"`    /*  任务ID。  */
	State           int32                                                                        `json:"state,omitempty"`     /*  动作执行状态。<br><li>0：任务完成<br><li>1：任务失败<br><li>2：任务进行中<br><li>3：任务未开始  */
	StartTime       int64                                                                        `json:"startTime,omitempty"` /*  开始时间毫秒时间戳。  */
	EndTime         int64                                                                        `json:"endTime,omitempty"`   /*  结束时间毫秒时间戳，当actionCode=disk-burn或cpu-fullload时有效。  */
	ActionParameter []*CtgkafkaChaosListReturnObjDataInjectActionInstanceActionParameterResponse `json:"actionParameter"`     /*  动作执行参数。  */
	Logs            []*CtgkafkaChaosListReturnObjDataInjectActionInstanceLogsResponse            `json:"logs"`                /*  演练任务过程日志。  */
}

type CtgkafkaChaosListReturnObjDataRecoveryActionInstanceActionParameterResponse struct {
	Code  string `json:"code,omitempty"`  /*  属性编码。  */
	Value string `json:"value,omitempty"` /*  属性值。  */
}

type CtgkafkaChaosListReturnObjDataRecoveryActionInstanceLogsResponse struct {
	StepName    string `json:"stepName,omitempty"`    /*  步骤名称。  */
	SubStepName string `json:"subStepName,omitempty"` /*  子步骤名称。  */
	LogLevel    string `json:"logLevel,omitempty"`    /*  日志级别。<br><li>INFO<br><li>ERROR  */
	StepResult  string `json:"stepResult,omitempty"`  /*  步骤结果。<br><li>PROCESSING：处理中<br><li>SUCCESS：成功<br><li>ERROR：错误<br><li>RETRYING：重试中  */
	Msg         string `json:"msg,omitempty"`         /*  日志内容。  */
	LogTime     string `json:"logTime,omitempty"`     /*  日志时间。  */
}

type CtgkafkaChaosListReturnObjDataRecoveryActionInstanceResponse struct {
	TaskId          string                                                                         `json:"taskId,omitempty"`    /*  任务ID。  */
	State           int32                                                                          `json:"state,omitempty"`     /*  动作执行状态。<br><li>0：任务完成<br><li>1：任务失败<br><li>2：任务进行中<br><li>3：任务未开始  */
	StartTime       int64                                                                          `json:"startTime,omitempty"` /*  开始时间毫秒时间戳。  */
	EndTime         int64                                                                          `json:"endTime,omitempty"`   /*  结束时间毫秒时间戳，当actionCode=disk-burn或cpu-fullload时有效。  */
	ActionParameter []*CtgkafkaChaosListReturnObjDataRecoveryActionInstanceActionParameterResponse `json:"actionParameter"`     /*  动作执行参数。  */
	Logs            []*CtgkafkaChaosListReturnObjDataRecoveryActionInstanceLogsResponse            `json:"logs"`                /*  演练任务过程日志。  */
}

type CtgkafkaChaosListReturnObjDataResponse struct {
	ExperimentId           string                                                        `json:"experimentId,omitempty"` /*  故障演练ID，故障注入与故障恢复一起构成完整的一次故障演练。使用该ID查询故障执行详情与执行撤销故障。  */
	Action                 *CtgkafkaChaosListReturnObjDataActionResponse                 `json:"action"`                 /*  故障演练动作信息。  */
	CreateDate             int64                                                         `json:"createDate,omitempty"`   /*  演练创建毫秒时间戳。  */
	InjectActionInstance   *CtgkafkaChaosListReturnObjDataInjectActionInstanceResponse   `json:"injectActionInstance"`   /*  故障注入任务。  */
	RecoveryActionInstance *CtgkafkaChaosListReturnObjDataRecoveryActionInstanceResponse `json:"recoveryActionInstance"` /*  故障撤销任务。  */
}

type CtgkafkaChaosListReturnObjResponse struct {
	Total int32                                     `json:"total,omitempty"` /*  总记录数。  */
	Data  []*CtgkafkaChaosListReturnObjDataResponse `json:"data"`            /*  故障演练信息。  */
}

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

type CtgkafkaChaosQueryReqMsgRequest struct {
	RegionId     string `json:"regionId,omitempty"`     /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId   string `json:"prodInstId,omitempty"`   /*  实例ID。  */
	ExperimentId string `json:"experimentId,omitempty"` /*  故障演练ID。  */
	TaskId       string `json:"taskId,omitempty"`       /*  任务ID。  */
}

type CtgkafkaChaosQueryReqMsgResponse struct {
	StatusCode int32                                      `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900。  */
	Message    string                                     `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaChaosQueryReqMsgReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                     `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaChaosQueryReqMsgReturnObjResponse struct {
	NodeKillType int32    `json:"nodeKillType,omitempty"` /*  节点宕机模式。  */
	Nodes        []string `json:"nodes"`                  /*  故障演练节点对象列表。  */
	Duration     int32    `json:"duration,omitempty"`     /*  故障演练持续时间。  */
	CpuPercent   int32    `json:"cpuPercent,omitempty"`   /*  演练CPU负载率。  */
}

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

type CtgkafkaConsumerGroupBatchDeleteRequest struct {
	RegionId   string   `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string   `json:"prodInstId,omitempty"` /*  实例ID。  */
	GroupNames []string `json:"groupNames"`           /*  消费组名称列表。  */
}

type CtgkafkaConsumerGroupBatchDeleteResponse struct {
	StatusCode string                                             `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                             `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaConsumerGroupBatchDeleteReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                             `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaConsumerGroupBatchDeleteReturnObjResponse struct {
	Data string `json:"data,omitempty"` /*  返回数据。  */
}

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

type CtgkafkaConsumerGroupCreateV3Request struct {
	RegionId    string `json:"regionId,omitempty"`    /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId  string `json:"prodInstId,omitempty"`  /*  实例ID。  */
	GroupName   string `json:"groupName,omitempty"`   /*  消费组名称，规则如下：<br><li>以英文字母、数字、下划线开头，且只能由英文字母、数字、句点、中划线、下划线组成<br><li>长度3-64。<br><li>名称不可重复。  */
	Description string `json:"description,omitempty"` /*  消费组描述，规则如下：<br><li>不能以+,-,@,= 特殊字符开头。 <br><li>长度不能大于200。  */
}

type CtgkafkaConsumerGroupCreateV3Response struct {
	StatusCode string                                          `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                          `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaConsumerGroupCreateV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                          `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaConsumerGroupCreateV3ReturnObjResponse struct {
	Data string `json:"data,omitempty"` /*  返回数据。  */
}

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

type CtgkafkaConsumerGroupDeleteV3Request struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
	GroupName  string `json:"groupName,omitempty"`  /*  消费组名称。  */
}

type CtgkafkaConsumerGroupDeleteV3Response struct {
	StatusCode string                                          `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                          `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaConsumerGroupDeleteV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                          `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaConsumerGroupDeleteV3ReturnObjResponse struct {
	Data string `json:"data,omitempty"` /*  返回数据。  */
}

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

type CtgkafkaConsumerGroupInstancesV3Request struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
	GroupName  string `json:"groupName,omitempty"`  /*  消费组名称。  */
}

type CtgkafkaConsumerGroupInstancesV3Response struct {
	StatusCode string                                             `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                             `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaConsumerGroupInstancesV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                             `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaConsumerGroupInstancesV3ReturnObjDataResponse struct {
	ConsumerId      string                                                                `json:"consumerId,omitempty"` /*  消费者ID。  */
	ClientId        string                                                                `json:"clientId,omitempty"`   /*  客户端ID。  */
	Host            string                                                                `json:"host,omitempty"`       /*  客户端地址。  */
	TopicPartitions *CtgkafkaConsumerGroupInstancesV3ReturnObjDataTopicPartitionsResponse `json:"topicPartitions"`      /*  消费者正在消费的分区，Map的key为主题名称，value为主题的分区序号列表。  */
}

type CtgkafkaConsumerGroupInstancesV3ReturnObjDataTopicPartitionsResponse struct{}

type CtgkafkaConsumerGroupInstancesV3ReturnObjResponse struct {
	Data []*CtgkafkaConsumerGroupInstancesV3ReturnObjDataResponse `json:"data"` /*  返回消费者列表信息。  */
}

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

type CtgkafkaConsumerGroupQueryV3Request struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
	GroupName  string `json:"groupName,omitempty"`  /*  消费组名称，模糊查询。  */
	PageNum    string `json:"pageNum,omitempty"`    /*  分页中的页数，默认1，范围1-40000。  */
	PageSize   string `json:"pageSize,omitempty"`   /*  分页中的每页大小，默认10，范围1-40000。  */
}

type CtgkafkaConsumerGroupQueryV3Response struct {
	StatusCode string                                         `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                         `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaConsumerGroupQueryV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                         `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaConsumerGroupQueryV3ReturnObjDataResponse struct {
	Id          int32  `json:"id,omitempty"`          /*  消费组ID。  */
	Name        string `json:"name,omitempty"`        /*  消费组名。  */
	Description string `json:"description,omitempty"` /*  消费组描述。  */
	Ctime       string `json:"ctime,omitempty"`       /*  创建时间。  */
}

type CtgkafkaConsumerGroupQueryV3ReturnObjResponse struct {
	Data  []*CtgkafkaConsumerGroupQueryV3ReturnObjDataResponse `json:"data"`            /*  返回数据。  */
	Total int32                                                `json:"total,omitempty"` /*  总记录数。  */
}

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

type CtgkafkaConsumerGroupResetV3PartitionShiftListRequest struct {
	Partition int32 `json:"partition,omitempty"` /*  主题分区号。  */
	ShiftBy   int64 `json:"shiftBy,omitempty"`   /*  主题分区消费位点向左或向右移动的相对位置，例如当前offset是1000，当shiftBy=-10重置后offset=990，当shiftBy=10重置后offset=1010。  */
}

type CtgkafkaConsumerGroupResetV3Request struct {
	RegionId           string                                                   `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId         string                                                   `json:"prodInstId,omitempty"` /*  实例ID。  */
	GroupName          string                                                   `json:"groupName,omitempty"`  /*  消费组名称。  */
	TopicName          string                                                   `json:"topicName,omitempty"`  /*  主题名称。  */
	RawType            int32                                                    `json:"type,omitempty"`       /*  类型，<li>0：重置到latest。 <li>1：按时间重置。<li>2：重置到earliest。<li>3：按位点重置，此类型参数partitionShiftList为必填。  */
	PartitionShiftList []*CtgkafkaConsumerGroupResetV3PartitionShiftListRequest `json:"partitionShiftList"`   /*  位点重置列表，当type为3时必填。  */
	Time               int64                                                    `json:"time,omitempty"`       /*  重置时间点毫秒时间戳，type=1时必填。  */
}

type CtgkafkaConsumerGroupResetV3Response struct {
	ReturnObj  *CtgkafkaConsumerGroupResetV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Message    string                                         `json:"message,omitempty"`    /*  描述状态。  */
	StatusCode string                                         `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Error      string                                         `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaConsumerGroupResetV3ReturnObjResponse struct {
	Data string `json:"data,omitempty"` /*  返回数据。  */
}

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

type CtgkafkaConsumerGroupStatusV3Request struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
	GroupName  string `json:"groupName,omitempty"`  /*  消费组名称。  */
	TopicName  string `json:"topicName,omitempty"`  /*  topic名称。  */
}

type CtgkafkaConsumerGroupStatusV3Response struct {
	StatusCode string                                          `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                          `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaConsumerGroupStatusV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                          `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaConsumerGroupStatusV3ReturnObjDataOffsetsResponse struct {
	Begin   int64 `json:"begin,omitempty"`   /*  最小点位。  */
	End     int64 `json:"end,omitempty"`     /*  最大点位。  */
	Current int64 `json:"current,omitempty"` /*  消费组消费当前位点。  */
	Lag     int64 `json:"lag,omitempty"`     /*  消息堆积。  */
	Total   int64 `json:"total,omitempty"`   /*  分区消息数总量。  */
	Hw      int64 `json:"hw,omitempty"`      /*  消息高水位线，所有副本均已确认写入的最高偏移量。  */
}

type CtgkafkaConsumerGroupStatusV3ReturnObjDataResponse struct {
	TopicName   string                                                     `json:"topicName,omitempty"`   /*  topic名称。  */
	PartitionId int32                                                      `json:"partitionId,omitempty"` /*  主题的分区序号。  */
	Offsets     *CtgkafkaConsumerGroupStatusV3ReturnObjDataOffsetsResponse `json:"offsets"`               /*  分区的消费进度状态。  */
}

type CtgkafkaConsumerGroupStatusV3ReturnObjResponse struct {
	Total int32                                                 `json:"total,omitempty"` /*  总记录数。  */
	Data  []*CtgkafkaConsumerGroupStatusV3ReturnObjDataResponse `json:"data"`            /*  消费组所订阅的主题状态列表。  */
}

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

type CtgkafkaConsumerGroupUpdateRequest struct {
	RegionId    string `json:"regionId,omitempty"`    /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId  string `json:"prodInstId,omitempty"`  /*  实例ID。  */
	GroupName   string `json:"groupName,omitempty"`   /*  消费组名称。  */
	Description string `json:"description,omitempty"` /*  消费组描述，规则如下：<br><li>不能以+,-,@,= 特殊字符开头。 <br><li>长度不能大于200。  */
}

type CtgkafkaConsumerGroupUpdateResponse struct {
	StatusCode string                                        `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                        `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaConsumerGroupUpdateReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                        `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaConsumerGroupUpdateReturnObjResponse struct {
	Data string `json:"data,omitempty"` /*  返回数据。  */
}

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

type CtgkafkaConsumerGroupUpdatetopicsV3Request struct {
	RegionId         string   `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId       string   `json:"prodInstId,omitempty"` /*  实例ID。  */
	GroupName        string   `json:"groupName,omitempty"`  /*  消费组名称。  */
	AddTopicNames    []string `json:"addTopicNames"`        /*  需要订阅的主题，和deleteTopicNames不能同时为空。  */
	DeleteTopicNames []string `json:"deleteTopicNames"`     /*  取消订阅的主题，和addTopicNames不能同时为空。  */
}

type CtgkafkaConsumerGroupUpdatetopicsV3Response struct {
	StatusCode string                                                `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                                `json:"message,omitempty"`    /*  提示信息。  */
	ReturnObj  *CtgkafkaConsumerGroupUpdatetopicsV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                                `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaConsumerGroupUpdatetopicsV3ReturnObjResponse struct {
	Data string `json:"data,omitempty"` /*  返回数据。  */
}

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

type CtgkafkaCreateOrderRequest struct {
	RegionId            string   `json:"regionId,omitempty"`            /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProjectId           string   `json:"projectId,omitempty"`           /*  企业项目ID(默认值：0)。您可以通过 <a href="https://www.ctyun.cn/document/10017248/10017965">查看企业项目资源</a> 获取企业项目ID。  */
	CycleCnt            int32    `json:"cycleCnt,omitempty"`            /*  付费周期，单位为月，取值：1~6,12,24,36。  */
	ClusterName         string   `json:"clusterName,omitempty"`         /*  实例名称。<br>规则：长度4~40个字符，大小写字母开头，只能包含大小写字母、数字及分隔符(-)，大小写字母或数字结尾，实例名称不可重复。  */
	EngineVersion       string   `json:"engineVersion,omitempty"`       /*  实例的引擎版本，默认为3.6。<li>2.8：2.8.x的引擎版本<li>3.6：3.6.x的引擎版本  */
	SpecName            string   `json:"specName,omitempty"`            /*  实例的规格类型，资源池所具备的规格可通过查询产品规格接口获取，默认可选如下：<br>计算增强型的规格可选为：<li>kafka.2u4g.cluster<li>kafka.4u8g.cluster<li>kafka.8u16g.cluster<li>kafka.12u24g.cluster<li>kafka.16u32g.cluster<li>kafka.24u48g.cluster<li>kafka.32u64g.cluster<li>kafka.48u96g.cluster<li>kafka.64u128g.cluster <br>海光-计算增强型的规格可选为：<li>kafka.hg.2u4g.cluster<li>kafka.hg.4u8g.cluster<li>kafka.hg.8u16g.cluster<li>kafka.hg.16u32g.cluster<li>kafka.hg.32u64g.cluster <br>鲲鹏-计算增强型的规格可选为：<li>kafka.kp.2u4g.cluster<li>kafka.kp.4u8g.cluster<li>kafka.kp.8u16g.cluster<li>kafka.kp.16u32g.cluster<li>kafka.kp.32u64g.cluster  */
	NodeNum             int32    `json:"nodeNum,omitempty"`             /*  节点数。单机版为1个，集群版3~50个。  */
	ZoneList            []string `json:"zoneList"`                      /*  实例所在可用区信息。只能填一个（单可用区）或三个（多可用区），可用区信息可调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5855&data=87&isNormal=1&vid=81">资源池可用区查询</a>API接口查询。  */
	DiskType            string   `json:"diskType,omitempty"`            /*  磁盘类型，资源池所具备的磁盘类型可通过查询产品规格接口获取，默认取值：<li>SAS：高IO<li>SSD：超高IO<li>FAST-SSD：极速型SSD  */
	DiskSize            int32    `json:"diskSize,omitempty"`            /*  单个节点的磁盘存储空间，单位为GB，存储空间取值范围100GB ~ 10000，并且为100的倍数。实例总存储空间为diskSize * nodeNum。  */
	VpcId               string   `json:"vpcId,omitempty"`               /*  VPC网络ID。获取方法如下：<li>方法一：登录网络控制台界面，在虚拟私有云的详情页面查找VPC ID。<li>方法二：您可以通过 <a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=18&api=4814&data=94&vid=88">查询VPC列表</a> vpcID字段获取。  */
	SubnetId            string   `json:"subnetId,omitempty"`            /*  VPC子网ID。获取方法如下：<li>方法一：登录网络控制台界面，单击VPC下的子网，进入子网详情页面，查找子网ID。<li>方法二：您可以通过 <a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=18&api=8659&data=94&vid=88">查询子网列表</a> subnetID字段获取。  */
	SecurityGroupId     string   `json:"securityGroupId,omitempty"`     /*  安全组ID。获取方法如下：<li>方法一：登录网络控制台界面，在安全组的详情页面查找安全组ID。<li>方法二：您可以通过 <a href="https://eop.ctyun.cn/ebp/searchCtapi/ctApiDebug?product=18&api=4817&vid=88">查询用户安全组列表</a> id字段获取。  */
	InstanceNum         int32    `json:"instanceNum,omitempty"`         /*  购买数量(1-100，默认1)  */
	EnableIpv6          *bool    `json:"enableIpv6"`                    /*  是否启用IPv6，默认为false。<li>true：启用IPv6。<li>false：不启用IPv6，默认值。  */
	PlainPort           int32    `json:"plainPort,omitempty"`           /*  公共接入点(PLAINTEXT)端口，范围在8000到9100之间，默认为8090。  */
	SaslPort            int32    `json:"saslPort,omitempty"`            /*  安全接入点(SASL_PLAINTEXT)端口，范围在8000到9100之间，默认为8092。  */
	SslPort             int32    `json:"sslPort,omitempty"`             /*  SSL接入点(SASL_SSL)端口，范围在8000到9100之间，默认为8098。  */
	HttpPort            int32    `json:"httpPort,omitempty"`            /*  HTTP接入点端口，范围在8000到9100之间，默认为8082。  */
	RetentionHours      int32    `json:"retentionHours,omitempty"`      /*  实例消息保留时长，默认为72小时，可选1~10000小时。  */
	AutoRenewStatus     *bool    `json:"autoRenewStatus"`               /*  过期是否自动续订。，默认为false。<li>true：自动续订。<li>false：不自动续订，默认值。  */
	AutoRenewCycleCount int32    `json:"autoRenewCycleCount,omitempty"` /*  自动续订时间长，当autoRenewStatus为true时必填，取值：1~6。  */
}

type CtgkafkaCreateOrderResponse struct {
	StatusCode string                                `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaCreateOrderReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaCreateOrderReturnObjResponse struct {
	Data CtgkafkaCreateOrderReturnObjResponseData `json:"data,omitempty"` /*  返回数据。  */
}

type CtgkafkaCreateOrderReturnObjResponseData struct {
	Submitted  bool   `json:"submitted"`
	NewOrderId string `json:"newOrderId"`
	NewOrderNo string `json:"newOrderNo"`
}

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

type CtgkafkaCreatePostPayOrderRequest struct {
	RegionId        string   `json:"regionId,omitempty"`        /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProjectId       string   `json:"projectId,omitempty"`       /*  企业项目ID(默认值：0)。您可以通过 <a href="https://www.ctyun.cn/document/10017248/10017965">查看企业项目资源</a> 获取企业项目ID。  */
	ClusterName     string   `json:"clusterName,omitempty"`     /*  实例名称。<br>规则：长度4~40个字符，大小写字母开头，只能包含大小写字母、数字及分隔符(-)，大小写字母或数字结尾，实例名称不可重复。  */
	EngineVersion   string   `json:"engineVersion,omitempty"`   /*  实例的引擎版本，默认为3.6。<li>2.8：2.8.x的引擎版本<li>3.6：3.6.x的引擎版本  */
	SpecName        string   `json:"specName,omitempty"`        /*  实例的规格类型，资源池所具备的规格可通过查询产品规格接口获取，默认可选如下：<br>计算增强型的规格可选为：<li>kafka.2u4g.cluster<li>kafka.4u8g.cluster<li>kafka.8u16g.cluster<li>kafka.12u24g.cluster<li>kafka.16u32g.cluster<li>kafka.24u48g.cluster<li>kafka.32u64g.cluster<li>kafka.48u96g.cluster<li>kafka.64u128g.cluster <br>海光-计算增强型的规格可选为：<li>kafka.hg.2u4g.cluster<li>kafka.hg.4u8g.cluster<li>kafka.hg.8u16g.cluster<li>kafka.hg.16u32g.cluster<li>kafka.hg.32u64g.cluster <br>鲲鹏-计算增强型的规格可选为：<li>kafka.kp.2u4g.cluster<li>kafka.kp.4u8g.cluster<li>kafka.kp.8u16g.cluster<li>kafka.kp.16u32g.cluster<li>kafka.kp.32u64g.cluster  */
	NodeNum         int32    `json:"nodeNum,omitempty"`         /*  节点数。单机版为1个，集群版3~50个。  */
	ZoneList        []string `json:"zoneList"`                  /*  实例所在可用区信息。只能填一个（单可用区）或三个（多可用区），可用区信息可调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5855&data=87&isNormal=1&vid=81">资源池可用区查询</a>API接口查询。  */
	DiskType        string   `json:"diskType,omitempty"`        /*  磁盘类型，资源池所具备的磁盘类型可通过查询产品规格接口获取，默认取值：<li>SAS：高IO<li>SSD：超高IO<li>FAST-SSD：极速型SSD  */
	DiskSize        int32    `json:"diskSize,omitempty"`        /*  单个节点的磁盘存储空间，单位为GB，存储空间取值范围100GB ~ 10000，并且为100的倍数。实例总存储空间为diskSize * nodeNum。  */
	VpcId           string   `json:"vpcId,omitempty"`           /*  VPC网络ID。获取方法如下：<li>方法一：登录网络控制台界面，在虚拟私有云的详情页面查找VPC ID。<li>方法二：您可以通过 <a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=18&api=4814&data=94&vid=88">查询VPC列表</a> vpcID字段获取。  */
	SubnetId        string   `json:"subnetId,omitempty"`        /*  VPC子网ID。获取方法如下：<li>方法一：登录网络控制台界面，单击VPC下的子网，进入子网详情页面，查找子网ID。<li>方法二：您可以通过 <a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=18&api=8659&data=94&vid=88">查询子网列表</a> subnetID字段获取。  */
	SecurityGroupId string   `json:"securityGroupId,omitempty"` /*  安全组ID。获取方法如下：<li>方法一：登录网络控制台界面，在安全组的详情页面查找安全组ID。<li>方法二：您可以通过 <a href="https://eop.ctyun.cn/ebp/searchCtapi/ctApiDebug?product=18&api=4817&vid=88">查询用户安全组列表</a> id字段获取。  */
	InstanceNum     int32    `json:"instanceNum,omitempty"`     /*  购买数量(1-100，默认1)  */
	EnableIpv6      *bool    `json:"enableIpv6"`                /*  是否启用IPv6，默认为false。<li>true：启用IPv6。<li>false：不启用IPv6，默认值。  */
	PlainPort       int32    `json:"plainPort,omitempty"`       /*  公共接入点(PLAINTEXT)端口，范围在8000到9100之间，默认为8090。  */
	SaslPort        int32    `json:"saslPort,omitempty"`        /*  安全接入点(SASL_PLAINTEXT)端口，范围在8000到9100之间，默认为8092。  */
	SslPort         int32    `json:"sslPort,omitempty"`         /*  SSL接入点(SASL_SSL)端口，范围在8000到9100之间，默认为8098。  */
	HttpPort        int32    `json:"httpPort,omitempty"`        /*  HTTP接入点端口，范围在8000到9100之间，默认为8082。  */
	RetentionHours  int32    `json:"retentionHours,omitempty"`  /*  实例消息保留时长，默认为72小时，可选1~10000小时。  */
}

type CtgkafkaCreatePostPayOrderResponse struct {
	StatusCode string                                       `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                       `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaCreatePostPayOrderReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                       `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaCreatePostPayOrderReturnObjResponse struct {
	Data CtgkafkaCreatePostPayOrderReturnObjResponseData `json:"data,omitempty"` /*  返回数据。  */
}

type CtgkafkaCreatePostPayOrderReturnObjResponseData struct {
	Submitted  bool   `json:"submitted"`
	NewOrderId string `json:"newOrderId"`
	NewOrderNo string `json:"newOrderNo"`
	TotalPrice string `json:"totalPrice"`
}

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

type CtgkafkaDeleteAuthorityRequest struct {
	RegionId             string   `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId           string   `json:"prodInstId,omitempty"` /*  实例ID。  */
	Username             string   `json:"username,omitempty"`   /*  用户名称。  */
	DeleteWriteAuthority []string `json:"deleteWriteAuthority"` /*  要删除生产权限的主题名称列表。与deleteReadAuthority至少一个不为空。  */
	DeleteReadAuthority  []string `json:"deleteReadAuthority"`  /*  要删除消费权限的主题名称列表。与deleteWriteAuthority至少一个不为空。  */
}

type CtgkafkaDeleteAuthorityResponse struct {
	StatusCode string                                    `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                    `json:"message,omitempty"`    /*  提示信息。  */
	ReturnObj  *CtgkafkaDeleteAuthorityReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                    `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaDeleteAuthorityReturnObjResponse struct {
	Data string `json:"data,omitempty"` /*  返回创建描述。  */
}

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

type CtgkafkaDiskExtendRequest struct {
	RegionId       string `json:"regionId,omitempty"`       /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId     string `json:"prodInstId,omitempty"`     /*  实例ID。  */
	DiskExtendSize string `json:"diskExtendSize,omitempty"` /*  每个节点扩容后的存储空间，单位GB，范围为当前每个节点存储空间 ~ 10000，并且为100的倍数。  */
	AutoPay        *bool  `json:"autoPay"`                  /*  是否自动支付，当实例为按需计费模式不生效。<br><li>true：自动付费(默认值)<br><li>false：手动付费 <br>说明：选择为手动付费时，您需要在控制台的顶部菜单栏进入控制中心，单击费用中心 ，然后单击左侧导航栏的订单管理 > 我的订单，找到目标订单进行支付。  */
}

type CtgkafkaDiskExtendResponse struct {
	StatusCode string                               `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                               `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaDiskExtendReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                               `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaDiskExtendReturnObjResponse struct {
}

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

type CtgkafkaDiskShrinkRequest struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
	DiskSize   string `json:"diskSize,omitempty"`   /*  每个节点缩容后的存储空间，单位GB，范围为当100 ~ 前每个节点存储空间，并且为100的倍数。  */
}

type CtgkafkaDiskShrinkResponse struct {
	StatusCode string                               `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                               `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaDiskShrinkReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                               `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaDiskShrinkReturnObjResponse struct {
}

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

type CtgkafkaElasticBandwidthRequest struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
	Enable     int32  `json:"enable,omitempty"`     /*  是否开启弹性带宽：<br><li>1：开启<br><li>2：关闭  */
}

type CtgkafkaElasticBandwidthResponse struct {
	StatusCode string                                     `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                     `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaElasticBandwidthReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                     `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaElasticBandwidthReturnObjDataResponse struct{}

type CtgkafkaElasticBandwidthReturnObjResponse struct {
	Data *CtgkafkaElasticBandwidthReturnObjDataResponse `json:"data"` /*  返回接口提示。  */
}

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

type CtgkafkaEnableAutoReassignRequest struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
	Enable     int32  `json:"enable,omitempty"`     /*  是否开启自动分区重平衡。<br><li>1：开启<br><li>2：关闭  */
}

type CtgkafkaEnableAutoReassignResponse struct {
	StatusCode string                                       `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                       `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaEnableAutoReassignReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                       `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaEnableAutoReassignReturnObjDataResponse struct{}

type CtgkafkaEnableAutoReassignReturnObjResponse struct {
	Data *CtgkafkaEnableAutoReassignReturnObjDataResponse `json:"data"` /*  返回数据。  */
}

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

type CtgkafkaEndMessageRequest struct {
	RegionId    string `json:"regionId,omitempty"`    /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId  string `json:"prodInstId,omitempty"`  /*  实例ID。  */
	TopicName   string `json:"topicName,omitempty"`   /*  主题名称。  */
	PartitionId int32  `json:"partitionId,omitempty"` /*  主题分区ID。  */
}

type CtgkafkaEndMessageResponse struct {
	StatusCode int32                                `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900。  */
	Message    string                               `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaEndMessageReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                               `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaEndMessageReturnObjDataResponse struct {
	TopicName string `json:"topicName,omitempty"` /*  主题名称。  */
	Partition int32  `json:"partition,omitempty"` /*  分区ID。  */
	Offset    int64  `json:"offset,omitempty"`    /*  最新消息偏移量。  */
	TimeStamp int64  `json:"timeStamp,omitempty"` /*  最新消息时间戳。  */
}

type CtgkafkaEndMessageReturnObjResponse struct {
	Data []*CtgkafkaEndMessageReturnObjDataResponse `json:"data"` /*  主题信息。  */
}

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

type CtgkafkaGetAuthorityRequest struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
	Username   string `json:"username,omitempty"`   /*  用户名称。  */
}

type CtgkafkaGetAuthorityResponse struct {
	StatusCode string                                 `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                 `json:"message,omitempty"`    /*  提示信息  */
	ReturnObj  *CtgkafkaGetAuthorityReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                 `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaGetAuthorityReturnObjDataResponse struct {
	Username             string   `json:"username,omitempty"`   /*  用户名  */
	ReadAuthorityTopics  []string `json:"readAuthorityTopics"`  /*  拥有消费权限的主题列表  */
	WriteAuthorityTopics []string `json:"writeAuthorityTopics"` /*  拥有生产权限的主题列表  */
}

type CtgkafkaGetAuthorityReturnObjResponse struct {
	Data *CtgkafkaGetAuthorityReturnObjDataResponse `json:"data"` /*  用户权限数据  */
}

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

type CtgkafkaGetInstanceConfigRequest struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
}

type CtgkafkaGetInstanceConfigResponse struct {
	StatusCode string                                      `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                      `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaGetInstanceConfigReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                      `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaGetInstanceConfigReturnObjDataResponse struct {
	Name          string `json:"name,omitempty"`          /*  配置名称  */
	Value         string `json:"value,omitempty"`         /*  当前配置值  */
	Valid_values  string `json:"valid_values,omitempty"`  /*  配置有效值。  */
	Default_value string `json:"default_value,omitempty"` /*  配置默认值。  */
	VarType       string `json:"varType,omitempty"`       /*  值类型。  */
	Config_type   string `json:"config_type,omitempty"`   /*  配置类型：<br><li>static：静态配置<br><li>dynamic：动态配置 <br>说明：静态配置修改后需重启实例方可生效，动态配置无需重启实例。  */
	Desc          string `json:"desc,omitempty"`          /*  配置说明。  */
}

type CtgkafkaGetInstanceConfigReturnObjResponse struct {
	Data []*CtgkafkaGetInstanceConfigReturnObjDataResponse `json:"data"` /*  返回数据  */
}

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

type CtgkafkaGetTopicDetailsRequest struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
	TopicName  string `json:"topicName,omitempty"`  /*  主题名称。  */
}

type CtgkafkaGetTopicDetailsResponse struct {
	StatusCode int32                                     `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900。  */
	Message    string                                    `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaGetTopicDetailsReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                    `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaGetTopicDetailsReturnObjDataPartitionListOffsetsResponse struct {
	Total      int64 `json:"total,omitempty"`      /*  分区消息总数。  */
	Begin      int64 `json:"begin,omitempty"`      /*  分区leader副本的最大偏移量。  */
	End        int64 `json:"end,omitempty"`        /*  分区leader副本的最小偏移量。  */
	UpdateTime int64 `json:"updateTime,omitempty"` /*  分区最近写入消息的毫秒时间戳。  */
	Hw         int64 `json:"hw,omitempty"`         /*  分区消息高水位线，所有副本均已确认写入的最大偏移量。  */
}

type CtgkafkaGetTopicDetailsReturnObjDataPartitionListReplicasResponse struct {
	BrokerId int32 `json:"brokerId,omitempty"` /*  Broker节点ID。  */
	IsLeader *bool `json:"isLeader"`           /*  是否是主副本。  */
	InSync   *bool `json:"inSync"`             /*  副本是否处于同步状态。  */
	Size     int64 `json:"size,omitempty"`     /*  副本消息大小，单位字节。  */
	Lag      int64 `json:"lag,omitempty"`      /*  该副本当前落后hw的消息数。  */
}

type CtgkafkaGetTopicDetailsReturnObjDataPartitionListResponse struct {
	TopicName   string                                                               `json:"topicName,omitempty"`   /*  主题名称。  */
	PartitionId int32                                                                `json:"partitionId,omitempty"` /*  分区ID。  */
	Offsets     *CtgkafkaGetTopicDetailsReturnObjDataPartitionListOffsetsResponse    `json:"offsets"`               /*  分区偏移量信息。  */
	Replicas    []*CtgkafkaGetTopicDetailsReturnObjDataPartitionListReplicasResponse `json:"replicas"`              /*  副本信息。  */
}

type CtgkafkaGetTopicDetailsReturnObjDataResponse struct {
	TopicName       string                                                       `json:"topicName,omitempty"` /*  主题名称。  */
	PartitionList   []*CtgkafkaGetTopicDetailsReturnObjDataPartitionListResponse `json:"partitionList"`       /*  分区列表信息。  */
	GroupSubscribed []string                                                     `json:"groupSubscribed"`     /*  订阅主题的消费组列表。  */
}

type CtgkafkaGetTopicDetailsReturnObjResponse struct {
	Data []*CtgkafkaGetTopicDetailsReturnObjDataResponse `json:"data"` /*  主题详情信息。  */
}

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

type CtgkafkaInstQueryRequest struct {
	RegionId       string `json:"regionId,omitempty"`       /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId     string `json:"prodInstId,omitempty"`     /*  实例ID，如果传入，则返回指定实例的详细信息。  */
	Name           string `json:"name,omitempty"`           /*  实例名称。  */
	ExactMatchName *bool  `json:"exactMatchName"`           /*  是否精确匹配实例名称，当name有值时本参数有效。<br><li>true：精确查询<br><li>false：模糊查询（默认）  */
	Status         int32  `json:"status,omitempty"`         /*  实例状态：<br><li>1：运行中<br><li>2：已过期<br><li>3：已注销<br><li>4：变更中<br><li>5：已退订<br><li>6：开通中<br><li>7：已取消<br><li>8：已停止<br><li>9：弹性IP处理中<br><li>10：重启中<br><li>11：重启失败<br><li>12：升级中<br><li>13：已欠费<br><li>101：开通失败  */
	OuterProjectId string `json:"outerProjectId,omitempty"` /*  企业项目ID，企业项目管理服务提供统一的云资源按企业项目管理，以及企业项目内的资源管理，成员管理。您可以通过查看<a href="https://www.ctyun.cn/document/10017248/10017961">创建企业项目</a>了解如何创建企业项目。  */
	PageNum        int32  `json:"pageNum,omitempty"`        /*  分页中的页数，默认1，范围1-40000。  */
	PageSize       int32  `json:"pageSize,omitempty"`       /*  分页中的每页大小，默认10，范围1-40000。  */
}

type CtgkafkaInstQueryResponse struct {
	StatusCode string                              `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                              `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaInstQueryReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                              `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaInstQueryReturnObjDataNodeListResponse struct {
	TenantId       string `json:"tenantId,omitempty"`       /*  租户ID。  */
	TenantName     string `json:"tenantName,omitempty"`     /*  租户名称。  */
	VpcIp          string `json:"vpcIp,omitempty"`          /*  节点VPC IP地址。  */
	VpcIpv6        string `json:"vpcIpv6,omitempty"`        /*  节点VPC IP地址。  */
	ElasticIp      string `json:"elasticIp,omitempty"`      /*  弹性IP，绑定后有值。  */
	ElasticIpState int32  `json:"elasticIpState,omitempty"` /*  弹性IP绑定状态。<br><li>0：未绑定<br><li>1：绑定成功<br><li>2：绑定失败<br><li>3：处理中<br><li>4：解绑失败  */
	CreateTime     string `json:"createTime,omitempty"`     /*  节点创建时间。  */
	UpdateTime     string `json:"updateTime,omitempty"`     /*  节点更新时间。  */
	ServerSeq      int32  `json:"serverSeq,omitempty"`      /*  节点ID。  */
	State          int32  `json:"state,omitempty"`          /*  节点专题。<br><li>0：停止<br><li>1：启动  */
	AzId           string `json:"azId,omitempty"`           /*  节点所在可用区ID。  */
	AzName         string `json:"azName,omitempty"`         /*  节点所在可用区名称。  */
	EcsId          string `json:"ecsId,omitempty"`          /*  节点ID。  */
	VpcPort        string `json:"vpcPort,omitempty"`        /*  公共接入点（PLAINTEXT）端口。  */
	SaslPort       string `json:"saslPort,omitempty"`       /*  安全接入点（SASL_PLAINTEXT）端口。  */
	ListenNodePort string `json:"listenNodePort,omitempty"` /*  SSL接入点(SASL_SSL)端口。  */
	Ipv6PlainPort  string `json:"ipv6PlainPort,omitempty"`  /*  IPV6公共接入点（PLAINTEXT）端口。  */
	Ipv6SaslPort   string `json:"ipv6SaslPort,omitempty"`   /*  IPV6安全接入点（SASL_PLAINTEXT）端口。  */
	Ipv6SslPort    string `json:"ipv6SslPort,omitempty"`    /*  IPV6 SSL接入点(SASL_SSL)端口。  */
	HttpPort       string `json:"httpPort,omitempty"`       /*  HTTP接入点端口。  */
	SaslNodePort   string `json:"saslNodePort,omitempty"`   /*  弹性IP安全接入点（SASL_PLAINTEXT）端口。  */
	DomainEndpoint string `json:"domainEndpoint,omitempty"` /*  域名。  */
}

type CtgkafkaInstQueryReturnObjDataProtocolsResponse struct {
	PlainTextAddr         string `json:"plainTextAddr,omitempty"`         /*  公共接入点。  */
	PlainTextIpv6Addr     string `json:"plainTextIpv6Addr,omitempty"`     /*  IPv6公共接入点。  */
	SaslPlainTextAddr     string `json:"saslPlainTextAddr,omitempty"`     /*  安全接入点。  */
	SaslPlainTextIpv6Addr string `json:"saslPlainTextIpv6Addr,omitempty"` /*  IPv6安全接入点。  */
	SaslSslAddr           string `json:"saslSslAddr,omitempty"`           /*  SSL安全接入点。  */
	SaslSslIpv6Addr       string `json:"saslSslIpv6Addr,omitempty"`       /*  IPv6 SSL安全接入点。  */
	HttpAddr              string `json:"httpAddr,omitempty"`              /*  HTTP接入点。  */
	HttpIpv6Addr          string `json:"httpIpv6Addr,omitempty"`          /*  IPv6 HTTP接入点。  */
	PublicSaslTextAddr    string `json:"publicSaslTextAddr,omitempty"`    /*  公网接入点。  */
	DomainEndpointAddr    string `json:"domainEndpointAddr,omitempty"`    /*  域名接入点。  */
	EnableIPv6            *bool  `json:"enableIPv6"`                      /*  是否开启IPv6  */
}

type CtgkafkaInstQueryReturnObjDataResponse struct {
	ProdInstId       string                                            `json:"prodInstId,omitempty"`       /*  实例ID。  */
	InstanceName     string                                            `json:"instanceName,omitempty"`     /*  实例名称。  */
	Status           int32                                             `json:"status,omitempty"`           /*  状态：<br><li>1：正常<br><li>2：暂停<br><li>3：注销  */
	MqEngineType     string                                            `json:"mqEngineType,omitempty"`     /*  产品引擎类型：<br><li>kafka<br><li>pulsar  */
	PartitionNum     int32                                             `json:"partitionNum,omitempty"`     /*  分区数上限。  */
	Subnet           string                                            `json:"subnet,omitempty"`           /*  子网名称。  */
	Space            string                                            `json:"space,omitempty"`            /*  单个代理（节点）磁盘存储空间，单位GB。  */
	SecurityGroup    string                                            `json:"securityGroup,omitempty"`    /*  安全组ID。  */
	Network          string                                            `json:"network,omitempty"`          /*  网络名称。  */
	BillMode         string                                            `json:"billMode,omitempty"`         /*  付费类型。<br><li>1：包周期<br><li>2：按需  */
	ExpireTime       string                                            `json:"expireTime,omitempty"`       /*  过期时间。  */
	CreateTime       string                                            `json:"createTime,omitempty"`       /*  创建时间。  */
	UpdateTime       string                                            `json:"updateTime,omitempty"`       /*  更新时间。  */
	NodeList         []*CtgkafkaInstQueryReturnObjDataNodeListResponse `json:"nodeList"`                   /*  代理（节点）列表信息，当请求参数传入prodInstId时有值  */
	Version          string                                            `json:"version,omitempty"`          /*  实例版本。  */
	RegionCode       string                                            `json:"regionCode,omitempty"`       /*  资源池编码。  */
	RegionName       string                                            `json:"regionName,omitempty"`       /*  资源池名称。  */
	OuterProjectId   string                                            `json:"outerProjectId,omitempty"`   /*  企业项目ID。  */
	OuterProjectName string                                            `json:"outerProjectName,omitempty"` /*  企业项目名称。  */
	DomainEndpoint   string                                            `json:"domainEndpoint,omitempty"`   /*  实例域名接入点。  */
	Remark           string                                            `json:"remark,omitempty"`           /*  实例备注。  */
	ClusterType      int32                                             `json:"clusterType,omitempty"`      /*  实例类型。<br><li>1：单机版<br><li>2：集群版  */
	Specifications   string                                            `json:"specifications,omitempty"`   /*  实例规格。  */
	VpcId            string                                            `json:"vpcId,omitempty"`            /*  VPC ID。  */
	SubnetId         string                                            `json:"subnetId,omitempty"`         /*  子网ID。  */
	AutoReassign     int32                                             `json:"autoReassign,omitempty"`     /*  扩容时是否自动迁移主题。 <br><li>1：是<br><li>2：否<br><li>空值表示不开启  */
	Ipv6Enable       int32                                             `json:"ipv6Enable,omitempty"`       /*  是否开启IPV6。 <br><li>1：是<br><li>2：否<br><li>空值表示不开启  */
	ElasticEnable    string                                            `json:"elasticEnable,omitempty"`    /*  是否开启弹性带宽。 <br><li>1：是<br><li>2：否<br><li>空值表示不开启  */
	Vip              string                                            `json:"vip,omitempty"`              /*  实例vip。  */
	Vipv6            string                                            `json:"vipv6,omitempty"`            /*  实例vipv6。  */
	DiskType         string                                            `json:"diskType,omitempty"`         /*  磁盘类型。  */
	Protocols        *CtgkafkaInstQueryReturnObjDataProtocolsResponse  `json:"protocols"`                  /*  实例接入点信息，当请求参数传入prodInstId时有值。  */
}

type CtgkafkaInstQueryReturnObjResponse struct {
	Total int32                                     `json:"total,omitempty"` /*  总记录数。  */
	Data  []*CtgkafkaInstQueryReturnObjDataResponse `json:"data"`            /*  实例信息。  */
}

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

type CtgkafkaInstanceDeleteV3Request struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
}

type CtgkafkaInstanceDeleteV3Response struct {
	StatusCode string                                     `json:"statusCode"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                     `json:"message"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaInstanceDeleteV3ReturnObjResponse `json:"returnObj"`  /*  返回对象。  */
	Error      string                                     `json:"error"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaInstanceDeleteV3ReturnObjResponse struct {
	Data string `json:"data"` /*  返回数据。  */
}

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

type CtgkafkaInstancesModifyNameV3Request struct {
	RegionId     string `json:"regionId,omitempty"`     /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId   string `json:"prodInstId,omitempty"`   /*  实例ID。  */
	InstanceName string `json:"instanceName,omitempty"` /*  新实例名称。 规则如下：<br><li>大小写字母开头，只能包含大小写字母、数字及分隔符(-)，大小写字母或数字结尾。<br><li>长度4-40。  */
}

type CtgkafkaInstancesModifyNameV3Response struct {
	StatusCode string                                          `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                          `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaInstancesModifyNameV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                          `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaInstancesModifyNameV3ReturnObjResponse struct {
	Data string `json:"data,omitempty"` /*  返回数据。  */
}

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

type CtgkafkaInstancesRestartV3Request struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
}

type CtgkafkaInstancesRestartV3Response struct {
	StatusCode string                                       `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                       `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaInstancesRestartV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                       `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaInstancesRestartV3ReturnObjResponse struct {
	Data string `json:"data"` /*  返回数据。  */
}

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

type CtgkafkaListResourceV3Request struct {
	RegionId string `json:"regionId,omitempty"` /*  资源池编码  */
	TagId    string `json:"tagId,omitempty"`    /*  标签ID  */
}

type CtgkafkaListResourceV3Response struct {
	StatusCode string `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900  */
	Message    string `json:"message,omitempty"`    /*  状态信息  */
	Error      string `json:"error,omitempty"`      /*  错误码，描述错误信息  */
}

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

type CtgkafkaListTagV3Request struct {
	RegionId string `json:"regionId,omitempty"` /*  资源池编码  */
	TagName  string `json:"tagName,omitempty"`  /*  标签名称  */
	PageNum  string `json:"pageNum,omitempty"`  /*  分页中的页数，默认1  */
	PageSize string `json:"pageSize,omitempty"` /*  分页中的每页大小，默认10  */
}

type CtgkafkaListTagV3Response struct {
	StatusCode string `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900  */
	Message    string `json:"message,omitempty"`    /*  状态信息  */
	Error      string `json:"error,omitempty"`      /*  错误码，描述错误信息  */
}

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

type CtgkafkaMirrorTaskRequest struct {
	RegionId            string `json:"regionId,omitempty"`            /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId          string `json:"prodInstId,omitempty"`          /*  目标实例ID。  */
	TaskName            string `json:"taskName,omitempty"`            /*  迁移任务名称。  */
	SourceAddr          string `json:"sourceAddr,omitempty"`          /*  源集群的接入点地址，迁移上云时为必填。  */
	SourceProtocol      string `json:"sourceProtocol,omitempty"`      /*  源集群的接入协议，迁移上云时为必填。<br><li>PLAINTEXT<br><li>SASL_PLAINTEXT  */
	SourceSaslMechanism string `json:"sourceSaslMechanism,omitempty"` /*  sasl认证机制，sasl连接时为必填。<br><li>PLAIN<br><li>SCRAM-SHA-256<br><li>SCRAM-SHA-512  */
	SourceSaslUser      string `json:"sourceSaslUser,omitempty"`      /*  sasl用户名称，sasl连接时为必填。  */
	SourceSaslPwd       string `json:"sourceSaslPwd,omitempty"`       /*  sasl用户密码，sasl连接时为必填。  */
	TaskNum             int32  `json:"taskNum,omitempty"`             /*  任务数，默认为1。  */
	SyncAcl             string `json:"syncAcl,omitempty"`             /*  是否同步acl信息。<br><li>1：是<br><li>2：否（默认值）  */
	SyncGroup           string `json:"syncGroup,omitempty"`           /*  是否同步消费组。<br><li>1：是<br><li>2：否（默认值）  */
	Topics              string `json:"topics,omitempty"`              /*  迁移的Topic名称，多个Topic用逗号隔开，不填默认所有Topic。  */
	Groups              string `json:"groups,omitempty"`              /*  迁移的消费组名称，多个消费组用逗号隔开，不填默认所有消费组。  */
	AutoStopTask        string `json:"autoStopTask,omitempty"`        /*  是否自动停止任务。<br><li>1：是<br><li>2：否（默认值）  */
	RawType             string `json:"type,omitempty"`                /*  迁移类型。<br><li>2：本地实例迁移上云<br><li>3：云间实例迁移  */
	SourceClusterId     string `json:"sourceClusterId,omitempty"`     /*  源集群ID，云实例间迁移时必填。  */
	DefaultReplica      string `json:"defaultReplica,omitempty"`      /*  是否保持和源集群副本一致。<br><li>1：是（默认值）<br><li>2：否，3副本  */
}

type CtgkafkaMirrorTaskResponse struct {
	StatusCode string                               `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                               `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaMirrorTaskReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                               `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaMirrorTaskReturnObjResponse struct {
	Data string `json:"data,omitempty"` /*  返回提升。  */
}

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

type CtgkafkaModifyInstanceConfigRequest struct {
	RegionId        string `json:"regionId,omitempty"`        /*  资源池编码  */
	ProdInstId      string `json:"prodInstId,omitempty"`      /*  实例ID  */
	LogRetentionMs  string `json:"logRetentionMs,omitempty"`  /*  消息保留时长  */
	MessageMaxBytes string `json:"messageMaxBytes,omitempty"` /*  最大消息大小  */
}

type CtgkafkaModifyInstanceConfigResponse struct {
	StatusCode string `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900  */
	Message    string `json:"message,omitempty"`    /*  描述状态  */
	Error      string `json:"error,omitempty"`      /*  错误码，描述错误信息  */
}

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

type CtgkafkaModifypartitionNumV3Request struct {
	RegionId     string `json:"regionId,omitempty"`     /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId   string `json:"prodInstId,omitempty"`   /*  实例ID。  */
	TopicName    string `json:"topicName,omitempty"`    /*  主题名称，<br> 您可以<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=48&api=7396&data=83&isNormal=1&vid=330">查询主题</a> 获取对应实例下的主题名称列表。  */
	PartitionNum int32  `json:"partitionNum,omitempty"` /*  新分区数量，取值范围[旧分区数量+1，min(100, 实例剩余分区数量)]。实例剩余分区数量=实例分区上限-所有主题分区数之和。<br>您可以<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=48&api=7382&data=83&isNormal=1&vid=330">查询实例</a>查询对应实例下partitionNum获取分区数上限。<br>您可以<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=48&api=7396&data=83&isNormal=1&vid=330">查询主题</a>查询对应实例下主题的分区数量。  */
}

type CtgkafkaModifypartitionNumV3Response struct {
	StatusCode string                                         `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                         `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaModifypartitionNumV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                         `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaModifypartitionNumV3ReturnObjResponse struct {
	Data string `json:"data,omitempty"` /*  返回数据。  */
}

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

type CtgkafkaMonitorMetricsV3Request struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	RegionCode string `json:"regionCode,omitempty"` /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
	MetricName string `json:"metricName,omitempty"` /*  指标名称，例如节点存活数指标，对应的metricName为current_brokers <br>您可以<a href="https://www.ctyun.cn/document/10029624/10991364">查询可用的指标名称</a>，参考该文档表格的指标ID。  */
	StartTime  int32  `json:"startTime,omitempty"`  /*  查询数据起始时间，UNIX时间戳，单位秒（s）。  */
	EndTime    int32  `json:"endTime,omitempty"`    /*  查询数据截止时间，UNIX时间戳，单位秒（s）。startTime必须小于endTime 。  */
	Labels     string `json:"labels,omitempty"`     /*  指标的维度标签，格式为：key1=value1,key2=value2，<br><li>节点维度监控指标，lebels可传vpcIp，如lebels参数为："vpcIp=192.168.0.46"。<br><li>主题维度监控指标lebels可传topic，如lebels参数为："topic=mytopic"。<br><li>消费组维度监控指标，lebels可传group、topic，如lebels参数为："group=aaaa,topic=topic-w"。  */
}

type CtgkafkaMonitorMetricsV3Response struct {
	StatusCode string                                       `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                       `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  []*CtgkafkaMonitorMetricsV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                       `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaMonitorMetricsV3ReturnObjMetricResponse struct{}

type CtgkafkaMonitorMetricsV3ReturnObjResponse struct {
	Metric *CtgkafkaMonitorMetricsV3ReturnObjMetricResponse   `json:"metric"` /*  metrics标签，标签如下：  <li>instance_id：实例ID<li>region_name：资源池名称 <li>vpc_ip：节点IP <li>topic：主题名 <li>group：消费组名称  */
	Values []*CtgkafkaMonitorMetricsV3ReturnObjValuesResponse `json:"values"` /*  指标数据列表。数据为一个数组，数组索引为0的数据时间戳，单位为秒；数组索引为1的数据为指标值。  */
}

type CtgkafkaMonitorMetricsV3ReturnObjValuesResponse struct {
	MetricValues []string `json:"metricValues"` /*  标指标数据，数组第一个数据为时时间戳，数组第二个数据为指标值。  */
}

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

type CtgkafkaNodeExtendRequest struct {
	RegionId      string `json:"regionId,omitempty"`      /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId    string `json:"prodInstId,omitempty"`    /*  实例ID。  实例需是集群版。  */
	ExtendNodeNum int32  `json:"extendNodeNum,omitempty"` /*  扩容后的节点数，取值范围[原来节点数+1, 50]。  */
	AutoPay       *bool  `json:"autoPay"`                 /*  是否自动支付，当实例为按需计费模式不生效。<br><li>true：自动付费(默认值)<br><li>false：手动付费 <br>说明：选择为手动付费时，您需要在控制台的顶部菜单栏进入控制中心，单击费用中心 ，然后单击左侧导航栏的订单管理 > 我的订单，找到目标订单进行支付。  */
}

type CtgkafkaNodeExtendResponse struct {
	StatusCode string                               `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                               `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaNodeExtendReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                               `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaNodeExtendReturnObjResponse struct {
}

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

type CtgkafkaNodeShrinkRequest struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。实例需是集群版。  */
	NodeNum    string `json:"nodeNum,omitempty"`    /*  缩容后的节点数。 取值范围[3, 原来节点数-1]。  */
}

type CtgkafkaNodeShrinkResponse struct {
	StatusCode string                               `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                               `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaNodeShrinkReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                               `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaNodeShrinkReturnObjResponse struct {
}

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

type CtgkafkaNodeStatusV3Request struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
}

type CtgkafkaNodeStatusV3Response struct {
	StatusCode string                                 `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                 `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaNodeStatusV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                 `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaNodeStatusV3ReturnObjDataResponse struct {
	Ip     string `json:"ip,omitempty"` /*  节点vpc ip  */
	Status *bool  `json:"status"`       /*  节点状态。<br><li>true：状态正常<br><li>false：状态异常  */
}

type CtgkafkaNodeStatusV3ReturnObjResponse struct {
	Data []*CtgkafkaNodeStatusV3ReturnObjDataResponse `json:"data"` /*  返回数据。  */
}

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

type CtgkafkaPageQueryFloatingipsRequest struct {
	RegionId string `json:"regionId,omitempty"` /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	PageNum  int32  `json:"pageNum,omitempty"`  /*  分页中的页数，默认1，范围1-40000。  */
	PageSize int32  `json:"pageSize,omitempty"` /*  分页中的每页大小，默认10，范围1-40000。  */
}

type CtgkafkaPageQueryFloatingipsResponse struct {
	StatusCode string `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  string `json:"returnObj,omitempty"`  /*  返回对象。此参数所包含的参数请见“响应示例'里面的注释。  */
	Error      string `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

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

type CtgkafkaProdDetailRequest struct {
	RegionId string `json:"regionId,omitempty"` /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
}

type CtgkafkaProdDetailResponse struct {
	StatusCode string                               `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"  */
	Message    string                               `json:"message,omitempty"`    /*  描述状态  */
	ReturnObj  *CtgkafkaProdDetailReturnObjResponse `json:"returnObj"`            /*  返回对象。此参数所包含的参数请见“响应示例”里面的注释  */
	Error      string                               `json:"error,omitempty"`      /*  错误码，描述错误信息  */
	RequestId  string                               `json:"requestId,omitempty"`
}

type CtgkafkaProdDetailReturnObjResponse struct {
	Data struct {
		Series []CtgkafkaProdDetailReturnObjResponseSeries `json:"series"`
		OsList []string                                    `json:"osList"`
	} `json:"data"`
}

type CtgkafkaProdDetailReturnObjResponseSeries struct {
	ProdId   string                                   `json:"prodId"`
	ProdName string                                   `json:"prodName"`
	ProdCode string                                   `json:"prodCode"`
	Sku      []CtgkafkaProdDetailReturnObjResponseSku `json:"sku"`
}

type CtgkafkaProdDetailReturnObjResponseSku struct {
	ProdId   string                                         `json:"prodId"`
	ProdName string                                         `json:"prodName"`
	ProdCode string                                         `json:"prodCode"`
	ResItem  CtgkafkaProdDetailReturnObjResponseSkuResItem  `json:"resItem"`
	DiskItem CtgkafkaProdDetailReturnObjResponseSkuDiskItem `json:"diskItem"`
}

type CtgkafkaProdDetailReturnObjResponseSkuDiskItem struct {
	ResType  string   `json:"resType"`
	ResName  string   `json:"resName"`
	ResItems []string `json:"resItems"`
}

type CtgkafkaProdDetailReturnObjResponseSkuResItem struct {
	ResType  string `json:"resType"`
	ResName  string `json:"resName"`
	ResItems []struct {
		CpuArch  string `json:"cpuArch"`
		HostType string `json:"hostType"`
		Spec     []struct {
			SpecName     string `json:"specName"`
			Description  string `json:"description"`
			Tps          int32  `json:"tps"`
			MaxPartition int32  `json:"maxPartition"`
			Flow         int32  `json:"flow"`
			Cpu          int32  `json:"cpu"`
			Memory       int32  `json:"memory"`
		} `json:"spec"`
	} `json:"resItems"`
}

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

type CtgkafkaProduceRequest struct {
	RegionId    string `json:"regionId,omitempty"`    /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId  string `json:"prodInstId,omitempty"`  /*  实例ID。  */
	TopicName   string `json:"topicName,omitempty"`   /*  主题名称。  */
	PartitionId int32  `json:"partitionId,omitempty"` /*  指定分区ID。  */
	Key         string `json:"key,omitempty"`         /*  消息key。  */
	Value       string `json:"value,omitempty"`       /*  消息内容。  */
	NumMessages int32  `json:"numMessages,omitempty"` /*  生产消息个数，取值区间[1, 10]，默认值1。  */
}

type CtgkafkaProduceResponse struct {
	StatusCode int32                             `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900。  */
	Message    string                            `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaProduceReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                            `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaProduceReturnObjResponse struct {
	Data   string `json:"data,omitempty"`   /*  返回数据。  */
	Result string `json:"result,omitempty"` /*  生产消息成功个数。  */
}

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

type CtgkafkaQueryCanUpdateVersionV3Request struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
}

type CtgkafkaQueryCanUpdateVersionV3Response struct {
	StatusCode string                                            `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                            `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaQueryCanUpdateVersionV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                            `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaQueryCanUpdateVersionV3ReturnObjResponse struct {
	Data []string `json:"data"` /*  返回可升级的版本号列表。  */
}

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

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

type CtgkafkaQueryMessageByOffsetV3Request struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
	TopicName  string `json:"topicName,omitempty"`  /*  topic名称。  */
	Offset     int64  `json:"offset,omitempty"`     /*  offset位置，大于或等于0。  */
	Partition  int32  `json:"partition,omitempty"`  /*  分区号，大于或等于0。  */
}

type CtgkafkaQueryMessageByOffsetV3Response struct {
	StatusCode string                                           `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                           `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaQueryMessageByOffsetV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                           `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaQueryMessageByOffsetV3ReturnObjDataResponse struct {
	Topic     string `json:"topic,omitempty"`     /*  主题名称。  */
	Partition int32  `json:"partition,omitempty"` /*  分区号。  */
	Offset    int64  `json:"offset,omitempty"`    /*  offset位置。  */
	Timestamp int64  `json:"timestamp,omitempty"` /*  生产消息的时间戳，单位毫秒。  */
	Key       string `json:"key,omitempty"`       /*  消息key。  */
	Value     string `json:"value,omitempty"`     /*  消息内容。  */
	Size      string `json:"size,omitempty"`      /*  消息大小，单位字节。  */
}

type CtgkafkaQueryMessageByOffsetV3ReturnObjResponse struct {
	Data []*CtgkafkaQueryMessageByOffsetV3ReturnObjDataResponse `json:"data"` /*  消息数据列表。  */
}

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

type CtgkafkaQueryMessageByTimestampV3Request struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
	TopicName  string `json:"topicName,omitempty"`  /*  topic名称。  */
	Timestamp  string `json:"timestamp,omitempty"`  /*  时间戳，单位毫秒。  */
	Partition  int32  `json:"partition,omitempty"`  /*  分区号。  */
}

type CtgkafkaQueryMessageByTimestampV3Response struct {
	StatusCode string                                              `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                              `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaQueryMessageByTimestampV3ReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                              `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaQueryMessageByTimestampV3ReturnObjDataResponse struct {
	Topic     string `json:"topic,omitempty"`     /*  主题名称。  */
	Partition int32  `json:"partition,omitempty"` /*  分区号。  */
	Offset    int64  `json:"offset,omitempty"`    /*  offset位置。  */
	Timestamp int64  `json:"timestamp,omitempty"` /*  生产消息的时间戳，单位毫秒。  */
	Key       string `json:"key,omitempty"`       /*  消息key。  */
	Value     string `json:"value,omitempty"`     /*  消息内容。  */
	Size      string `json:"size,omitempty"`      /*  消息大小，单位字节。  */
}

type CtgkafkaQueryMessageByTimestampV3ReturnObjResponse struct {
	Data []*CtgkafkaQueryMessageByTimestampV3ReturnObjDataResponse `json:"data"` /*  消息数据列表。  */
}

type CtgkafkaQueryMessageRequest struct {
	RegionId    string `json:"regionId,omitempty"`    /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId  string `json:"prodInstId,omitempty"`  /*  实例ID。  */
	TopicName   string `json:"topicName,omitempty"`   /*  topic名称。  */
	PartitionId int32  `json:"partitionId,omitempty"` /*  分区号，大于或等于0。  */
	StartTime   int64  `json:"startTime,omitempty"`   /*  时间戳，单位毫秒，endTime必须大于startTime。  */
	EndTime     int64  `json:"endTime,omitempty"`     /*  时间戳，单位毫秒，endTime必须大于startTime。  */
	Content     string `json:"content,omitempty"`     /*  消息包含内容  */
	PageNum     int32  `json:"pageNum,omitempty"`     /*  分页中的页数，默认1，范围1-40000。  */
	PageSize    int32  `json:"pageSize,omitempty"`    /*  分页中的每页大小，默认10，范围1-40000。  */
}

type CtgkafkaQueryMessageResponse struct {
	StatusCode string                                 `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功："800"，失败："900"。  */
	Message    string                                 `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaQueryMessageReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                 `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaQueryMessageReturnObjDataMessagesResponse struct {
	Topic     string `json:"topic,omitempty"`     /*  主题名称。  */
	Partition int32  `json:"partition,omitempty"` /*  分区号。  */
	Offset    int64  `json:"offset,omitempty"`    /*  offset位置。  */
	Timestamp int64  `json:"timestamp,omitempty"` /*  生产消息的时间戳，单位毫秒。  */
	Key       string `json:"key,omitempty"`       /*  消息Key。  */
	Value     string `json:"value,omitempty"`     /*  消息内容。  */
	Size      int32  `json:"size,omitempty"`      /*  消息大小。  */
}

type CtgkafkaQueryMessageReturnObjDataResponse struct {
	Messages []*CtgkafkaQueryMessageReturnObjDataMessagesResponse `json:"messages"` /*  消息信息。  */
}

type CtgkafkaQueryMessageReturnObjResponse struct {
	Data *CtgkafkaQueryMessageReturnObjDataResponse `json:"data"` /*  消息分页数据对象。  */
}

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

type CtgkafkaQueryProducersRequest struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
	TopicName  string `json:"topicName,omitempty"`  /*  主题名称。  */
}

type CtgkafkaQueryProducersResponse struct {
	StatusCode int32                                    `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900。  */
	Message    string                                   `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaQueryProducersReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                   `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaQueryProducersReturnObjResponse struct {
	Topic         string `json:"topic,omitempty"`         /*  主题名称。  */
	Address       string `json:"address,omitempty"`       /*  消费者客户端IP地址。  */
	BrokerAddress string `json:"brokerAddress,omitempty"` /*  Broker节点IP地址。  */
	JoinTime      int64  `json:"joinTime,omitempty"`      /*  生产者加入集群的时间戳。  */
	Expire        *bool  `json:"expire"`                  /*  生产者是否过期。  */
}

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

type CtgkafkaQuotaBrokerCreateRequest struct {
	RegionId         string `json:"regionId,omitempty"`         /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId       string `json:"prodInstId,omitempty"`       /*  实例ID，实例需是Kafka引擎类型且非单机版。  */
	ProducerByteRate int64  `json:"producerByteRate,omitempty"` /*  生产者流控上限，单位字节，单节点流控限制为producerByteRate/节点个数，取值范围[1*节点个数, 实例单节点最大流量*节点个数]，与consumerByteRate不能同时为空。<br>对应实例规格下的单节点流量规格：<li>kafka.2u4g.cluster:100MB<li>kafka.4u8g.cluster:200MB<li>kafka.8u16g.cluster:375MB<li>kafka.12u24g.cluster:625MB<li>kafka.16u32g.cluster:750MB<li>kafka.24u48g.cluster:1125MB<li>kafka.32u64g.cluster:1500MB<li>kafka.48u96g.cluster:2250MB<li>kafka.64u128g.cluster:3000MB <li>kafka.hg.2u4g.cluster:62MB<li>kafka.hg.4u8g.cluster:188MB<li>kafka.hg.8u16g.cluster:563MB<li>kafka.hg.16u32g.cluster:1063MB<li>kafka.hg.32u64g.cluster:2000MB<li>kafka.kp.2u4g.cluster:62MB<li>kafka.kp.4u8g.cluster:188MB<li>kafka.kp.8u16g.cluster:563MB<li>kafka.kp.16u32g.cluster:1063MB<li>kafka.kp.32u64g.cluster:2000MB  */
	ConsumerByteRate int64  `json:"consumerByteRate,omitempty"` /*  消费者流控上限，单位字节，单节点流控限制为consumerByteRate/节点个数，取值范围[1*节点个数, 实例单节点最大流量*节点个数]，与producerByteRate不能同时为空。<br>对应实例规格下的单节点流量规格：<li>kafka.2u4g.cluster:100MB<li>kafka.4u8g.cluster:200MB<li>kafka.8u16g.cluster:375MB<li>kafka.12u24g.cluster:625MB<li>kafka.16u32g.cluster:750MB<li>kafka.24u48g.cluster:1125MB<li>kafka.32u64g.cluster:1500MB<li>kafka.48u96g.cluster:2250MB<li>kafka.64u128g.cluster:3000MB <li>kafka.hg.2u4g.cluster:62MB<li>kafka.hg.4u8g.cluster:188MB<li>kafka.hg.8u16g.cluster:563MB<li>kafka.hg.16u32g.cluster:1063MB<li>kafka.hg.32u64g.cluster:2000MB<li>kafka.kp.2u4g.cluster:62MB<li>kafka.kp.4u8g.cluster:188MB<li>kafka.kp.8u16g.cluster:563MB<li>kafka.kp.16u32g.cluster:1063MB<li>kafka.kp.32u64g.cluster:2000MB  */
}

type CtgkafkaQuotaBrokerCreateResponse struct {
	StatusCode int32  `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900。  */
	Message    string `json:"message,omitempty"`    /*  描述状态。  */
}

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

type CtgkafkaQuotaBrokerDeleteRequest struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID，实例需是Kafka引擎类型且非单机版。  */
}

type CtgkafkaQuotaBrokerDeleteResponse struct {
	StatusCode int32  `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900。  */
	Message    string `json:"message,omitempty"`    /*  描述状态。  */
}

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

type CtgkafkaQuotaBrokerQueryRequest struct {
	RegionId   string `json:"regionId,omitempty"`   /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId string `json:"prodInstId,omitempty"` /*  实例ID。  */
}

type CtgkafkaQuotaBrokerQueryResponse struct {
	StatusCode int32                                      `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900。  */
	Message    string                                     `json:"message,omitempty"`    /*  描述状态。  */
	ReturnObj  *CtgkafkaQuotaBrokerQueryReturnObjResponse `json:"returnObj"`            /*  返回对象。  */
	Error      string                                     `json:"error,omitempty"`      /*  错误码，描述错误信息。  */
}

type CtgkafkaQuotaBrokerQueryReturnObjResponse struct {
	ProducerByteRate int64 `json:"producerByteRate,omitempty"` /*  生产者流控上限，单位字节。  */
	ConsumerByteRate int64 `json:"consumerByteRate,omitempty"` /*  消费者流控上限，单位字节。  */
}

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

type CtgkafkaQuotaBrokerUpdateRequest struct {
	RegionId         string `json:"regionId,omitempty"`         /*  实例的资源池ID。<br>获取方法如下：<br><li>方法一：通过查询<a href="https://www.ctyun.cn/document/10029624/11008434">分布式消息服务Kafka资源池附录文档</a>。<br><li>方法二：通过调用<a href="https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=25&api=5851&data=87&vid=81">查询可用的资源池</a>API接口查。  */
	ProdInstId       string `json:"prodInstId,omitempty"`       /*  实例ID，实例需是Kafka引擎类型且非单机版。  */
	ProducerByteRate int64  `json:"producerByteRate,omitempty"` /*  生产者流控上限，单位字节，单节点流控限制为producerByteRate/节点个数，取值范围[1*节点个数, 实例单节点最大流量*节点个数]，与consumerByteRate不能同时为空。<br>对应实例规格下的单节点流量规格：<li>kafka.2u4g.cluster:100MB<li>kafka.4u8g.cluster:200MB<li>kafka.8u16g.cluster:375MB<li>kafka.12u24g.cluster:625MB<li>kafka.16u32g.cluster:750MB<li>kafka.24u48g.cluster:1125MB<li>kafka.32u64g.cluster:1500MB<li>kafka.48u96g.cluster:2250MB<li>kafka.64u128g.cluster:3000MB <li>kafka.hg.2u4g.cluster:62MB<li>kafka.hg.4u8g.cluster:188MB<li>kafka.hg.8u16g.cluster:563MB<li>kafka.hg.16u32g.cluster:1063MB<li>kafka.hg.32u64g.cluster:2000MB<li>kafka.kp.2u4g.cluster:62MB<li>kafka.kp.4u8g.cluster:188MB<li>kafka.kp.8u16g.cluster:563MB<li>kafka.kp.16u32g.cluster:1063MB<li>kafka.kp.32u64g.cluster:2000MB  */
	ConsumerByteRate int64  `json:"consumerByteRate,omitempty"` /*  消费者流控上限，单位字节，单节点流控限制为consumerByteRate/节点个数，取值范围[1*节点个数, 实例单节点最大流量*节点个数]，与producerByteRate不能同时为空。<br>对应实例规格下的单节点流量规格：<li>kafka.2u4g.cluster:100MB<li>kafka.4u8g.cluster:200MB<li>kafka.8u16g.cluster:375MB<li>kafka.12u24g.cluster:625MB<li>kafka.16u32g.cluster:750MB<li>kafka.24u48g.cluster:1125MB<li>kafka.32u64g.cluster:1500MB<li>kafka.48u96g.cluster:2250MB<li>kafka.64u128g.cluster:3000MB <li>kafka.hg.2u4g.cluster:62MB<li>kafka.hg.4u8g.cluster:188MB<li>kafka.hg.8u16g.cluster:563MB<li>kafka.hg.16u32g.cluster:1063MB<li>kafka.hg.32u64g.cluster:2000MB<li>kafka.kp.2u4g.cluster:62MB<li>kafka.kp.4u8g.cluster:188MB<li>kafka.kp.8u16g.cluster:563MB<li>kafka.kp.16u32g.cluster:1063MB<li>kafka.kp.32u64g.cluster:2000MB  */
}

type CtgkafkaQuotaBrokerUpdateResponse struct {
	StatusCode int32  `json:"statusCode,omitempty"` /*  接口系统层面状态码。成功：800，失败：900。  */
	Message    string `json:"message,omitempty"`    /*  描述状态。  */
}

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