mse

package
v1.61.1038 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Apr 20, 2021 License: Apache-2.0 Imports: 6 Imported by: 3

Documentation

Index

Constants

This section is empty.

Variables

View Source
var EndpointMap map[string]string

EndpointMap Endpoint Data

View Source
var EndpointType = "regional"

EndpointType regional or central

Functions

func GetEndpointMap

func GetEndpointMap() map[string]string

GetEndpointMap Get Endpoint Data Map

func GetEndpointType

func GetEndpointType() string

GetEndpointType Get Endpoint Type Value

func SetClientProperty

func SetClientProperty(client *Client, propertyName string, propertyValue interface{})

SetClientProperty Set Property by Reflect

func SetEndpointDataToClient

func SetEndpointDataToClient(client *Client)

SetEndpointDataToClient Set EndpointMap and ENdpointType

Types

type AddMockRuleRequest added in v1.61.998

type AddMockRuleRequest struct {
	*requests.RpcRequest
	ExtraJson       string           `position:"Query" name:"ExtraJson"`
	ProviderAppId   string           `position:"Query" name:"ProviderAppId"`
	Source          string           `position:"Query" name:"Source"`
	Enable          requests.Boolean `position:"Query" name:"Enable"`
	ScMockItems     string           `position:"Query" name:"ScMockItems"`
	ProviderAppName string           `position:"Query" name:"ProviderAppName"`
	ConsumerAppIds  string           `position:"Query" name:"ConsumerAppIds"`
	DubboMockItems  string           `position:"Query" name:"DubboMockItems"`
	Name            string           `position:"Query" name:"Name"`
	Region          string           `position:"Query" name:"Region"`
}

AddMockRuleRequest is the request struct for api AddMockRule

func CreateAddMockRuleRequest added in v1.61.998

func CreateAddMockRuleRequest() (request *AddMockRuleRequest)

CreateAddMockRuleRequest creates a request to invoke AddMockRule API

type AddMockRuleResponse added in v1.61.998

type AddMockRuleResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code           int    `json:"Code" xml:"Code"`
	Success        bool   `json:"Success" xml:"Success"`
	Data           Data   `json:"Data" xml:"Data"`
}

AddMockRuleResponse is the response struct for api AddMockRule

func CreateAddMockRuleResponse added in v1.61.998

func CreateAddMockRuleResponse() (response *AddMockRuleResponse)

CreateAddMockRuleResponse creates a response to parse from AddMockRule response

type AlarmContactGroupModel

type AlarmContactGroupModel struct {
	ContactGroupName string `json:"ContactGroupName" xml:"ContactGroupName"`
	ContactGroupId   string `json:"ContactGroupId" xml:"ContactGroupId"`
}

AlarmContactGroupModel is a nested struct in mse response

type AlarmHistoryModel

type AlarmHistoryModel struct {
	AlarmTime     string `json:"AlarmTime" xml:"AlarmTime"`
	AlarmPhone    string `json:"AlarmPhone" xml:"AlarmPhone"`
	AlarmDingDing string `json:"AlarmDingDing" xml:"AlarmDingDing"`
	AlarmName     string `json:"AlarmName" xml:"AlarmName"`
	AlarmContent  string `json:"AlarmContent" xml:"AlarmContent"`
	AlarmEmail    string `json:"AlarmEmail" xml:"AlarmEmail"`
}

AlarmHistoryModel is a nested struct in mse response

type AlarmItem

type AlarmItem struct {
	AlarmCode   string `json:"AlarmCode" xml:"AlarmCode"`
	AlarmDesc   string `json:"AlarmDesc" xml:"AlarmDesc"`
	ClusterType string `json:"ClusterType" xml:"ClusterType"`
}

AlarmItem is a nested struct in mse response

type AlarmRuleModel

type AlarmRuleModel struct {
	AlarmStatus     string `json:"AlarmStatus" xml:"AlarmStatus"`
	AlarmName       string `json:"AlarmName" xml:"AlarmName"`
	CreateTime      string `json:"CreateTime" xml:"CreateTime"`
	AlarmRuleDetail string `json:"AlarmRuleDetail" xml:"AlarmRuleDetail"`
	AlarmRuleId     string `json:"AlarmRuleId" xml:"AlarmRuleId"`
}

AlarmRuleModel is a nested struct in mse response

type Client

type Client struct {
	sdk.Client
}

Client is the sdk client struct, each func corresponds to an OpenAPI

func NewClient

func NewClient() (client *Client, err error)

NewClient creates a sdk client with environment variables

func NewClientWithAccessKey

func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error)

NewClientWithAccessKey is a shortcut to create sdk client with accesskey usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithEcsRamRole

func NewClientWithEcsRamRole(regionId string, roleName string) (client *Client, err error)

NewClientWithEcsRamRole is a shortcut to create sdk client with ecs ram role usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithOptions

func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error)

NewClientWithOptions creates a sdk client with regionId/sdkConfig/credential this is the common api to create a sdk client

func NewClientWithProvider

func NewClientWithProvider(regionId string, providers ...provider.Provider) (client *Client, err error)

NewClientWithProvider creates a sdk client with providers usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArn

func NewClientWithRamRoleArn(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArnAndPolicy

func NewClientWithRamRoleArnAndPolicy(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName, policy string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn and policy usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRsaKeyPair

func NewClientWithRsaKeyPair(regionId string, publicKeyId, privateKey string, sessionExpiration int) (client *Client, err error)

NewClientWithRsaKeyPair is a shortcut to create sdk client with rsa key pair usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithStsToken

func NewClientWithStsToken(regionId, stsAccessKeyId, stsAccessKeySecret, stsToken string) (client *Client, err error)

NewClientWithStsToken is a shortcut to create sdk client with sts token usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func (*Client) AddMockRule added in v1.61.998

func (client *Client) AddMockRule(request *AddMockRuleRequest) (response *AddMockRuleResponse, err error)

AddMockRule invokes the mse.AddMockRule API synchronously

func (*Client) AddMockRuleWithCallback added in v1.61.998

func (client *Client) AddMockRuleWithCallback(request *AddMockRuleRequest, callback func(response *AddMockRuleResponse, err error)) <-chan int

AddMockRuleWithCallback invokes the mse.AddMockRule API asynchronously

func (*Client) AddMockRuleWithChan added in v1.61.998

func (client *Client) AddMockRuleWithChan(request *AddMockRuleRequest) (<-chan *AddMockRuleResponse, <-chan error)

AddMockRuleWithChan invokes the mse.AddMockRule API asynchronously

func (*Client) CloneNacosConfig added in v1.61.998

func (client *Client) CloneNacosConfig(request *CloneNacosConfigRequest) (response *CloneNacosConfigResponse, err error)

CloneNacosConfig invokes the mse.CloneNacosConfig API synchronously

func (*Client) CloneNacosConfigWithCallback added in v1.61.998

func (client *Client) CloneNacosConfigWithCallback(request *CloneNacosConfigRequest, callback func(response *CloneNacosConfigResponse, err error)) <-chan int

CloneNacosConfigWithCallback invokes the mse.CloneNacosConfig API asynchronously

func (*Client) CloneNacosConfigWithChan added in v1.61.998

func (client *Client) CloneNacosConfigWithChan(request *CloneNacosConfigRequest) (<-chan *CloneNacosConfigResponse, <-chan error)

CloneNacosConfigWithChan invokes the mse.CloneNacosConfig API asynchronously

func (*Client) CreateAlarmRule

func (client *Client) CreateAlarmRule(request *CreateAlarmRuleRequest) (response *CreateAlarmRuleResponse, err error)

CreateAlarmRule invokes the mse.CreateAlarmRule API synchronously

func (*Client) CreateAlarmRuleWithCallback

func (client *Client) CreateAlarmRuleWithCallback(request *CreateAlarmRuleRequest, callback func(response *CreateAlarmRuleResponse, err error)) <-chan int

CreateAlarmRuleWithCallback invokes the mse.CreateAlarmRule API asynchronously

func (*Client) CreateAlarmRuleWithChan

func (client *Client) CreateAlarmRuleWithChan(request *CreateAlarmRuleRequest) (<-chan *CreateAlarmRuleResponse, <-chan error)

CreateAlarmRuleWithChan invokes the mse.CreateAlarmRule API asynchronously

func (*Client) CreateApplication added in v1.61.1002

func (client *Client) CreateApplication(request *CreateApplicationRequest) (response *CreateApplicationResponse, err error)

CreateApplication invokes the mse.CreateApplication API synchronously

func (*Client) CreateApplicationWithCallback added in v1.61.1002

func (client *Client) CreateApplicationWithCallback(request *CreateApplicationRequest, callback func(response *CreateApplicationResponse, err error)) <-chan int

CreateApplicationWithCallback invokes the mse.CreateApplication API asynchronously

func (*Client) CreateApplicationWithChan added in v1.61.1002

func (client *Client) CreateApplicationWithChan(request *CreateApplicationRequest) (<-chan *CreateApplicationResponse, <-chan error)

CreateApplicationWithChan invokes the mse.CreateApplication API asynchronously

func (*Client) CreateCluster

func (client *Client) CreateCluster(request *CreateClusterRequest) (response *CreateClusterResponse, err error)

CreateCluster invokes the mse.CreateCluster API synchronously

func (*Client) CreateClusterWithCallback

func (client *Client) CreateClusterWithCallback(request *CreateClusterRequest, callback func(response *CreateClusterResponse, err error)) <-chan int

CreateClusterWithCallback invokes the mse.CreateCluster API asynchronously

func (*Client) CreateClusterWithChan

func (client *Client) CreateClusterWithChan(request *CreateClusterRequest) (<-chan *CreateClusterResponse, <-chan error)

CreateClusterWithChan invokes the mse.CreateCluster API asynchronously

func (*Client) CreateEngineNamespace

func (client *Client) CreateEngineNamespace(request *CreateEngineNamespaceRequest) (response *CreateEngineNamespaceResponse, err error)

CreateEngineNamespace invokes the mse.CreateEngineNamespace API synchronously

func (*Client) CreateEngineNamespaceWithCallback

func (client *Client) CreateEngineNamespaceWithCallback(request *CreateEngineNamespaceRequest, callback func(response *CreateEngineNamespaceResponse, err error)) <-chan int

CreateEngineNamespaceWithCallback invokes the mse.CreateEngineNamespace API asynchronously

func (*Client) CreateEngineNamespaceWithChan

func (client *Client) CreateEngineNamespaceWithChan(request *CreateEngineNamespaceRequest) (<-chan *CreateEngineNamespaceResponse, <-chan error)

CreateEngineNamespaceWithChan invokes the mse.CreateEngineNamespace API asynchronously

func (*Client) CreateNacosConfig

func (client *Client) CreateNacosConfig(request *CreateNacosConfigRequest) (response *CreateNacosConfigResponse, err error)

CreateNacosConfig invokes the mse.CreateNacosConfig API synchronously

func (*Client) CreateNacosConfigWithCallback

func (client *Client) CreateNacosConfigWithCallback(request *CreateNacosConfigRequest, callback func(response *CreateNacosConfigResponse, err error)) <-chan int

CreateNacosConfigWithCallback invokes the mse.CreateNacosConfig API asynchronously

func (*Client) CreateNacosConfigWithChan

func (client *Client) CreateNacosConfigWithChan(request *CreateNacosConfigRequest) (<-chan *CreateNacosConfigResponse, <-chan error)

CreateNacosConfigWithChan invokes the mse.CreateNacosConfig API asynchronously

func (*Client) CreateZnode

func (client *Client) CreateZnode(request *CreateZnodeRequest) (response *CreateZnodeResponse, err error)

CreateZnode invokes the mse.CreateZnode API synchronously

func (*Client) CreateZnodeWithCallback

func (client *Client) CreateZnodeWithCallback(request *CreateZnodeRequest, callback func(response *CreateZnodeResponse, err error)) <-chan int

CreateZnodeWithCallback invokes the mse.CreateZnode API asynchronously

func (*Client) CreateZnodeWithChan

func (client *Client) CreateZnodeWithChan(request *CreateZnodeRequest) (<-chan *CreateZnodeResponse, <-chan error)

CreateZnodeWithChan invokes the mse.CreateZnode API asynchronously

func (*Client) DeleteAlarmRule

func (client *Client) DeleteAlarmRule(request *DeleteAlarmRuleRequest) (response *DeleteAlarmRuleResponse, err error)

DeleteAlarmRule invokes the mse.DeleteAlarmRule API synchronously

func (*Client) DeleteAlarmRuleWithCallback

func (client *Client) DeleteAlarmRuleWithCallback(request *DeleteAlarmRuleRequest, callback func(response *DeleteAlarmRuleResponse, err error)) <-chan int

DeleteAlarmRuleWithCallback invokes the mse.DeleteAlarmRule API asynchronously

func (*Client) DeleteAlarmRuleWithChan

func (client *Client) DeleteAlarmRuleWithChan(request *DeleteAlarmRuleRequest) (<-chan *DeleteAlarmRuleResponse, <-chan error)

DeleteAlarmRuleWithChan invokes the mse.DeleteAlarmRule API asynchronously

func (*Client) DeleteCluster

func (client *Client) DeleteCluster(request *DeleteClusterRequest) (response *DeleteClusterResponse, err error)

DeleteCluster invokes the mse.DeleteCluster API synchronously

func (*Client) DeleteClusterWithCallback

func (client *Client) DeleteClusterWithCallback(request *DeleteClusterRequest, callback func(response *DeleteClusterResponse, err error)) <-chan int

DeleteClusterWithCallback invokes the mse.DeleteCluster API asynchronously

func (*Client) DeleteClusterWithChan

func (client *Client) DeleteClusterWithChan(request *DeleteClusterRequest) (<-chan *DeleteClusterResponse, <-chan error)

DeleteClusterWithChan invokes the mse.DeleteCluster API asynchronously

func (*Client) DeleteEngineNamespace

func (client *Client) DeleteEngineNamespace(request *DeleteEngineNamespaceRequest) (response *DeleteEngineNamespaceResponse, err error)

DeleteEngineNamespace invokes the mse.DeleteEngineNamespace API synchronously

func (*Client) DeleteEngineNamespaceWithCallback

func (client *Client) DeleteEngineNamespaceWithCallback(request *DeleteEngineNamespaceRequest, callback func(response *DeleteEngineNamespaceResponse, err error)) <-chan int

DeleteEngineNamespaceWithCallback invokes the mse.DeleteEngineNamespace API asynchronously

func (*Client) DeleteEngineNamespaceWithChan

func (client *Client) DeleteEngineNamespaceWithChan(request *DeleteEngineNamespaceRequest) (<-chan *DeleteEngineNamespaceResponse, <-chan error)

DeleteEngineNamespaceWithChan invokes the mse.DeleteEngineNamespace API asynchronously

func (*Client) DeleteNacosConfig

func (client *Client) DeleteNacosConfig(request *DeleteNacosConfigRequest) (response *DeleteNacosConfigResponse, err error)

DeleteNacosConfig invokes the mse.DeleteNacosConfig API synchronously

func (*Client) DeleteNacosConfigWithCallback

func (client *Client) DeleteNacosConfigWithCallback(request *DeleteNacosConfigRequest, callback func(response *DeleteNacosConfigResponse, err error)) <-chan int

DeleteNacosConfigWithCallback invokes the mse.DeleteNacosConfig API asynchronously

func (*Client) DeleteNacosConfigWithChan

func (client *Client) DeleteNacosConfigWithChan(request *DeleteNacosConfigRequest) (<-chan *DeleteNacosConfigResponse, <-chan error)

DeleteNacosConfigWithChan invokes the mse.DeleteNacosConfig API asynchronously

func (*Client) DeleteNacosConfigs

func (client *Client) DeleteNacosConfigs(request *DeleteNacosConfigsRequest) (response *DeleteNacosConfigsResponse, err error)

DeleteNacosConfigs invokes the mse.DeleteNacosConfigs API synchronously

func (*Client) DeleteNacosConfigsWithCallback

func (client *Client) DeleteNacosConfigsWithCallback(request *DeleteNacosConfigsRequest, callback func(response *DeleteNacosConfigsResponse, err error)) <-chan int

DeleteNacosConfigsWithCallback invokes the mse.DeleteNacosConfigs API asynchronously

func (*Client) DeleteNacosConfigsWithChan

func (client *Client) DeleteNacosConfigsWithChan(request *DeleteNacosConfigsRequest) (<-chan *DeleteNacosConfigsResponse, <-chan error)

DeleteNacosConfigsWithChan invokes the mse.DeleteNacosConfigs API asynchronously

func (*Client) DeleteNacosService added in v1.61.998

func (client *Client) DeleteNacosService(request *DeleteNacosServiceRequest) (response *DeleteNacosServiceResponse, err error)

DeleteNacosService invokes the mse.DeleteNacosService API synchronously

func (*Client) DeleteNacosServiceWithCallback added in v1.61.998

func (client *Client) DeleteNacosServiceWithCallback(request *DeleteNacosServiceRequest, callback func(response *DeleteNacosServiceResponse, err error)) <-chan int

DeleteNacosServiceWithCallback invokes the mse.DeleteNacosService API asynchronously

func (*Client) DeleteNacosServiceWithChan added in v1.61.998

func (client *Client) DeleteNacosServiceWithChan(request *DeleteNacosServiceRequest) (<-chan *DeleteNacosServiceResponse, <-chan error)

DeleteNacosServiceWithChan invokes the mse.DeleteNacosService API asynchronously

func (*Client) DeleteZnode

func (client *Client) DeleteZnode(request *DeleteZnodeRequest) (response *DeleteZnodeResponse, err error)

DeleteZnode invokes the mse.DeleteZnode API synchronously

func (*Client) DeleteZnodeWithCallback

func (client *Client) DeleteZnodeWithCallback(request *DeleteZnodeRequest, callback func(response *DeleteZnodeResponse, err error)) <-chan int

DeleteZnodeWithCallback invokes the mse.DeleteZnode API asynchronously

func (*Client) DeleteZnodeWithChan

func (client *Client) DeleteZnodeWithChan(request *DeleteZnodeRequest) (<-chan *DeleteZnodeResponse, <-chan error)

DeleteZnodeWithChan invokes the mse.DeleteZnode API asynchronously

func (*Client) ExportNacosConfig added in v1.61.998

func (client *Client) ExportNacosConfig(request *ExportNacosConfigRequest) (response *ExportNacosConfigResponse, err error)

ExportNacosConfig invokes the mse.ExportNacosConfig API synchronously

func (*Client) ExportNacosConfigWithCallback added in v1.61.998

func (client *Client) ExportNacosConfigWithCallback(request *ExportNacosConfigRequest, callback func(response *ExportNacosConfigResponse, err error)) <-chan int

ExportNacosConfigWithCallback invokes the mse.ExportNacosConfig API asynchronously

func (*Client) ExportNacosConfigWithChan added in v1.61.998

func (client *Client) ExportNacosConfigWithChan(request *ExportNacosConfigRequest) (<-chan *ExportNacosConfigResponse, <-chan error)

ExportNacosConfigWithChan invokes the mse.ExportNacosConfig API asynchronously

func (*Client) GetEngineNamepace

func (client *Client) GetEngineNamepace(request *GetEngineNamepaceRequest) (response *GetEngineNamepaceResponse, err error)

GetEngineNamepace invokes the mse.GetEngineNamepace API synchronously

func (*Client) GetEngineNamepaceWithCallback

func (client *Client) GetEngineNamepaceWithCallback(request *GetEngineNamepaceRequest, callback func(response *GetEngineNamepaceResponse, err error)) <-chan int

GetEngineNamepaceWithCallback invokes the mse.GetEngineNamepace API asynchronously

func (*Client) GetEngineNamepaceWithChan

func (client *Client) GetEngineNamepaceWithChan(request *GetEngineNamepaceRequest) (<-chan *GetEngineNamepaceResponse, <-chan error)

GetEngineNamepaceWithChan invokes the mse.GetEngineNamepace API asynchronously

func (*Client) GetImportFileUrl added in v1.61.998

func (client *Client) GetImportFileUrl(request *GetImportFileUrlRequest) (response *GetImportFileUrlResponse, err error)

GetImportFileUrl invokes the mse.GetImportFileUrl API synchronously

func (*Client) GetImportFileUrlWithCallback added in v1.61.998

func (client *Client) GetImportFileUrlWithCallback(request *GetImportFileUrlRequest, callback func(response *GetImportFileUrlResponse, err error)) <-chan int

GetImportFileUrlWithCallback invokes the mse.GetImportFileUrl API asynchronously

func (*Client) GetImportFileUrlWithChan added in v1.61.998

func (client *Client) GetImportFileUrlWithChan(request *GetImportFileUrlRequest) (<-chan *GetImportFileUrlResponse, <-chan error)

GetImportFileUrlWithChan invokes the mse.GetImportFileUrl API asynchronously

func (*Client) GetNacosConfig

func (client *Client) GetNacosConfig(request *GetNacosConfigRequest) (response *GetNacosConfigResponse, err error)

GetNacosConfig invokes the mse.GetNacosConfig API synchronously

func (*Client) GetNacosConfigWithCallback

func (client *Client) GetNacosConfigWithCallback(request *GetNacosConfigRequest, callback func(response *GetNacosConfigResponse, err error)) <-chan int

GetNacosConfigWithCallback invokes the mse.GetNacosConfig API asynchronously

func (*Client) GetNacosConfigWithChan

func (client *Client) GetNacosConfigWithChan(request *GetNacosConfigRequest) (<-chan *GetNacosConfigResponse, <-chan error)

GetNacosConfigWithChan invokes the mse.GetNacosConfig API asynchronously

func (*Client) GetNacosHistoryConfig

func (client *Client) GetNacosHistoryConfig(request *GetNacosHistoryConfigRequest) (response *GetNacosHistoryConfigResponse, err error)

GetNacosHistoryConfig invokes the mse.GetNacosHistoryConfig API synchronously

func (*Client) GetNacosHistoryConfigWithCallback

func (client *Client) GetNacosHistoryConfigWithCallback(request *GetNacosHistoryConfigRequest, callback func(response *GetNacosHistoryConfigResponse, err error)) <-chan int

GetNacosHistoryConfigWithCallback invokes the mse.GetNacosHistoryConfig API asynchronously

func (*Client) GetNacosHistoryConfigWithChan

func (client *Client) GetNacosHistoryConfigWithChan(request *GetNacosHistoryConfigRequest) (<-chan *GetNacosHistoryConfigResponse, <-chan error)

GetNacosHistoryConfigWithChan invokes the mse.GetNacosHistoryConfig API asynchronously

func (*Client) GetOverview added in v1.61.998

func (client *Client) GetOverview(request *GetOverviewRequest) (response *GetOverviewResponse, err error)

GetOverview invokes the mse.GetOverview API synchronously

func (*Client) GetOverviewWithCallback added in v1.61.998

func (client *Client) GetOverviewWithCallback(request *GetOverviewRequest, callback func(response *GetOverviewResponse, err error)) <-chan int

GetOverviewWithCallback invokes the mse.GetOverview API asynchronously

func (*Client) GetOverviewWithChan added in v1.61.998

func (client *Client) GetOverviewWithChan(request *GetOverviewRequest) (<-chan *GetOverviewResponse, <-chan error)

GetOverviewWithChan invokes the mse.GetOverview API asynchronously

func (*Client) ImportNacosConfig added in v1.61.998

func (client *Client) ImportNacosConfig(request *ImportNacosConfigRequest) (response *ImportNacosConfigResponse, err error)

ImportNacosConfig invokes the mse.ImportNacosConfig API synchronously

func (*Client) ImportNacosConfigWithCallback added in v1.61.998

func (client *Client) ImportNacosConfigWithCallback(request *ImportNacosConfigRequest, callback func(response *ImportNacosConfigResponse, err error)) <-chan int

ImportNacosConfigWithCallback invokes the mse.ImportNacosConfig API asynchronously

func (*Client) ImportNacosConfigWithChan added in v1.61.998

func (client *Client) ImportNacosConfigWithChan(request *ImportNacosConfigRequest) (<-chan *ImportNacosConfigResponse, <-chan error)

ImportNacosConfigWithChan invokes the mse.ImportNacosConfig API asynchronously

func (*Client) ListAlarmContactGroups

func (client *Client) ListAlarmContactGroups(request *ListAlarmContactGroupsRequest) (response *ListAlarmContactGroupsResponse, err error)

ListAlarmContactGroups invokes the mse.ListAlarmContactGroups API synchronously

func (*Client) ListAlarmContactGroupsWithCallback

func (client *Client) ListAlarmContactGroupsWithCallback(request *ListAlarmContactGroupsRequest, callback func(response *ListAlarmContactGroupsResponse, err error)) <-chan int

ListAlarmContactGroupsWithCallback invokes the mse.ListAlarmContactGroups API asynchronously

func (*Client) ListAlarmContactGroupsWithChan

func (client *Client) ListAlarmContactGroupsWithChan(request *ListAlarmContactGroupsRequest) (<-chan *ListAlarmContactGroupsResponse, <-chan error)

ListAlarmContactGroupsWithChan invokes the mse.ListAlarmContactGroups API asynchronously

func (*Client) ListAlarmHistories

func (client *Client) ListAlarmHistories(request *ListAlarmHistoriesRequest) (response *ListAlarmHistoriesResponse, err error)

ListAlarmHistories invokes the mse.ListAlarmHistories API synchronously

func (*Client) ListAlarmHistoriesWithCallback

func (client *Client) ListAlarmHistoriesWithCallback(request *ListAlarmHistoriesRequest, callback func(response *ListAlarmHistoriesResponse, err error)) <-chan int

ListAlarmHistoriesWithCallback invokes the mse.ListAlarmHistories API asynchronously

func (*Client) ListAlarmHistoriesWithChan

func (client *Client) ListAlarmHistoriesWithChan(request *ListAlarmHistoriesRequest) (<-chan *ListAlarmHistoriesResponse, <-chan error)

ListAlarmHistoriesWithChan invokes the mse.ListAlarmHistories API asynchronously

func (*Client) ListAlarmItems

func (client *Client) ListAlarmItems(request *ListAlarmItemsRequest) (response *ListAlarmItemsResponse, err error)

ListAlarmItems invokes the mse.ListAlarmItems API synchronously

func (*Client) ListAlarmItemsWithCallback

func (client *Client) ListAlarmItemsWithCallback(request *ListAlarmItemsRequest, callback func(response *ListAlarmItemsResponse, err error)) <-chan int

ListAlarmItemsWithCallback invokes the mse.ListAlarmItems API asynchronously

func (*Client) ListAlarmItemsWithChan

func (client *Client) ListAlarmItemsWithChan(request *ListAlarmItemsRequest) (<-chan *ListAlarmItemsResponse, <-chan error)

ListAlarmItemsWithChan invokes the mse.ListAlarmItems API asynchronously

func (*Client) ListAlarmRules

func (client *Client) ListAlarmRules(request *ListAlarmRulesRequest) (response *ListAlarmRulesResponse, err error)

ListAlarmRules invokes the mse.ListAlarmRules API synchronously

func (*Client) ListAlarmRulesWithCallback

func (client *Client) ListAlarmRulesWithCallback(request *ListAlarmRulesRequest, callback func(response *ListAlarmRulesResponse, err error)) <-chan int

ListAlarmRulesWithCallback invokes the mse.ListAlarmRules API asynchronously

func (*Client) ListAlarmRulesWithChan

func (client *Client) ListAlarmRulesWithChan(request *ListAlarmRulesRequest) (<-chan *ListAlarmRulesResponse, <-chan error)

ListAlarmRulesWithChan invokes the mse.ListAlarmRules API asynchronously

func (*Client) ListAnsInstances

func (client *Client) ListAnsInstances(request *ListAnsInstancesRequest) (response *ListAnsInstancesResponse, err error)

ListAnsInstances invokes the mse.ListAnsInstances API synchronously

func (*Client) ListAnsInstancesWithCallback

func (client *Client) ListAnsInstancesWithCallback(request *ListAnsInstancesRequest, callback func(response *ListAnsInstancesResponse, err error)) <-chan int

ListAnsInstancesWithCallback invokes the mse.ListAnsInstances API asynchronously

func (*Client) ListAnsInstancesWithChan

func (client *Client) ListAnsInstancesWithChan(request *ListAnsInstancesRequest) (<-chan *ListAnsInstancesResponse, <-chan error)

ListAnsInstancesWithChan invokes the mse.ListAnsInstances API asynchronously

func (*Client) ListAnsServiceClusters

func (client *Client) ListAnsServiceClusters(request *ListAnsServiceClustersRequest) (response *ListAnsServiceClustersResponse, err error)

ListAnsServiceClusters invokes the mse.ListAnsServiceClusters API synchronously

func (*Client) ListAnsServiceClustersWithCallback

func (client *Client) ListAnsServiceClustersWithCallback(request *ListAnsServiceClustersRequest, callback func(response *ListAnsServiceClustersResponse, err error)) <-chan int

ListAnsServiceClustersWithCallback invokes the mse.ListAnsServiceClusters API asynchronously

func (*Client) ListAnsServiceClustersWithChan

func (client *Client) ListAnsServiceClustersWithChan(request *ListAnsServiceClustersRequest) (<-chan *ListAnsServiceClustersResponse, <-chan error)

ListAnsServiceClustersWithChan invokes the mse.ListAnsServiceClusters API asynchronously

func (*Client) ListAnsServices

func (client *Client) ListAnsServices(request *ListAnsServicesRequest) (response *ListAnsServicesResponse, err error)

ListAnsServices invokes the mse.ListAnsServices API synchronously

func (*Client) ListAnsServicesWithCallback

func (client *Client) ListAnsServicesWithCallback(request *ListAnsServicesRequest, callback func(response *ListAnsServicesResponse, err error)) <-chan int

ListAnsServicesWithCallback invokes the mse.ListAnsServices API asynchronously

func (*Client) ListAnsServicesWithChan

func (client *Client) ListAnsServicesWithChan(request *ListAnsServicesRequest) (<-chan *ListAnsServicesResponse, <-chan error)

ListAnsServicesWithChan invokes the mse.ListAnsServices API asynchronously

func (*Client) ListClusterConnectionTypes added in v1.61.998

func (client *Client) ListClusterConnectionTypes(request *ListClusterConnectionTypesRequest) (response *ListClusterConnectionTypesResponse, err error)

ListClusterConnectionTypes invokes the mse.ListClusterConnectionTypes API synchronously

func (*Client) ListClusterConnectionTypesWithCallback added in v1.61.998

func (client *Client) ListClusterConnectionTypesWithCallback(request *ListClusterConnectionTypesRequest, callback func(response *ListClusterConnectionTypesResponse, err error)) <-chan int

ListClusterConnectionTypesWithCallback invokes the mse.ListClusterConnectionTypes API asynchronously

func (*Client) ListClusterConnectionTypesWithChan added in v1.61.998

func (client *Client) ListClusterConnectionTypesWithChan(request *ListClusterConnectionTypesRequest) (<-chan *ListClusterConnectionTypesResponse, <-chan error)

ListClusterConnectionTypesWithChan invokes the mse.ListClusterConnectionTypes API asynchronously

func (*Client) ListClusterTypes added in v1.61.998

func (client *Client) ListClusterTypes(request *ListClusterTypesRequest) (response *ListClusterTypesResponse, err error)

ListClusterTypes invokes the mse.ListClusterTypes API synchronously

func (*Client) ListClusterTypesWithCallback added in v1.61.998

func (client *Client) ListClusterTypesWithCallback(request *ListClusterTypesRequest, callback func(response *ListClusterTypesResponse, err error)) <-chan int

ListClusterTypesWithCallback invokes the mse.ListClusterTypes API asynchronously

func (*Client) ListClusterTypesWithChan added in v1.61.998

func (client *Client) ListClusterTypesWithChan(request *ListClusterTypesRequest) (<-chan *ListClusterTypesResponse, <-chan error)

ListClusterTypesWithChan invokes the mse.ListClusterTypes API asynchronously

func (*Client) ListClusterVersions added in v1.61.998

func (client *Client) ListClusterVersions(request *ListClusterVersionsRequest) (response *ListClusterVersionsResponse, err error)

ListClusterVersions invokes the mse.ListClusterVersions API synchronously

func (*Client) ListClusterVersionsWithCallback added in v1.61.998

func (client *Client) ListClusterVersionsWithCallback(request *ListClusterVersionsRequest, callback func(response *ListClusterVersionsResponse, err error)) <-chan int

ListClusterVersionsWithCallback invokes the mse.ListClusterVersions API asynchronously

func (*Client) ListClusterVersionsWithChan added in v1.61.998

func (client *Client) ListClusterVersionsWithChan(request *ListClusterVersionsRequest) (<-chan *ListClusterVersionsResponse, <-chan error)

ListClusterVersionsWithChan invokes the mse.ListClusterVersions API asynchronously

func (*Client) ListClusters

func (client *Client) ListClusters(request *ListClustersRequest) (response *ListClustersResponse, err error)

ListClusters invokes the mse.ListClusters API synchronously

func (*Client) ListClustersWithCallback

func (client *Client) ListClustersWithCallback(request *ListClustersRequest, callback func(response *ListClustersResponse, err error)) <-chan int

ListClustersWithCallback invokes the mse.ListClusters API asynchronously

func (*Client) ListClustersWithChan

func (client *Client) ListClustersWithChan(request *ListClustersRequest) (<-chan *ListClustersResponse, <-chan error)

ListClustersWithChan invokes the mse.ListClusters API asynchronously

func (*Client) ListEngineNamespaces

func (client *Client) ListEngineNamespaces(request *ListEngineNamespacesRequest) (response *ListEngineNamespacesResponse, err error)

ListEngineNamespaces invokes the mse.ListEngineNamespaces API synchronously

func (*Client) ListEngineNamespacesWithCallback

func (client *Client) ListEngineNamespacesWithCallback(request *ListEngineNamespacesRequest, callback func(response *ListEngineNamespacesResponse, err error)) <-chan int

ListEngineNamespacesWithCallback invokes the mse.ListEngineNamespaces API asynchronously

func (*Client) ListEngineNamespacesWithChan

func (client *Client) ListEngineNamespacesWithChan(request *ListEngineNamespacesRequest) (<-chan *ListEngineNamespacesResponse, <-chan error)

ListEngineNamespacesWithChan invokes the mse.ListEngineNamespaces API asynchronously

func (*Client) ListEurekaInstances

func (client *Client) ListEurekaInstances(request *ListEurekaInstancesRequest) (response *ListEurekaInstancesResponse, err error)

ListEurekaInstances invokes the mse.ListEurekaInstances API synchronously

func (*Client) ListEurekaInstancesWithCallback

func (client *Client) ListEurekaInstancesWithCallback(request *ListEurekaInstancesRequest, callback func(response *ListEurekaInstancesResponse, err error)) <-chan int

ListEurekaInstancesWithCallback invokes the mse.ListEurekaInstances API asynchronously

func (*Client) ListEurekaInstancesWithChan

func (client *Client) ListEurekaInstancesWithChan(request *ListEurekaInstancesRequest) (<-chan *ListEurekaInstancesResponse, <-chan error)

ListEurekaInstancesWithChan invokes the mse.ListEurekaInstances API asynchronously

func (*Client) ListEurekaServices

func (client *Client) ListEurekaServices(request *ListEurekaServicesRequest) (response *ListEurekaServicesResponse, err error)

ListEurekaServices invokes the mse.ListEurekaServices API synchronously

func (*Client) ListEurekaServicesWithCallback

func (client *Client) ListEurekaServicesWithCallback(request *ListEurekaServicesRequest, callback func(response *ListEurekaServicesResponse, err error)) <-chan int

ListEurekaServicesWithCallback invokes the mse.ListEurekaServices API asynchronously

func (*Client) ListEurekaServicesWithChan

func (client *Client) ListEurekaServicesWithChan(request *ListEurekaServicesRequest) (<-chan *ListEurekaServicesResponse, <-chan error)

ListEurekaServicesWithChan invokes the mse.ListEurekaServices API asynchronously

func (*Client) ListListenersByConfig

func (client *Client) ListListenersByConfig(request *ListListenersByConfigRequest) (response *ListListenersByConfigResponse, err error)

ListListenersByConfig invokes the mse.ListListenersByConfig API synchronously

func (*Client) ListListenersByConfigWithCallback

func (client *Client) ListListenersByConfigWithCallback(request *ListListenersByConfigRequest, callback func(response *ListListenersByConfigResponse, err error)) <-chan int

ListListenersByConfigWithCallback invokes the mse.ListListenersByConfig API asynchronously

func (*Client) ListListenersByConfigWithChan

func (client *Client) ListListenersByConfigWithChan(request *ListListenersByConfigRequest) (<-chan *ListListenersByConfigResponse, <-chan error)

ListListenersByConfigWithChan invokes the mse.ListListenersByConfig API asynchronously

func (*Client) ListListenersByIp

func (client *Client) ListListenersByIp(request *ListListenersByIpRequest) (response *ListListenersByIpResponse, err error)

ListListenersByIp invokes the mse.ListListenersByIp API synchronously

func (*Client) ListListenersByIpWithCallback

func (client *Client) ListListenersByIpWithCallback(request *ListListenersByIpRequest, callback func(response *ListListenersByIpResponse, err error)) <-chan int

ListListenersByIpWithCallback invokes the mse.ListListenersByIp API asynchronously

func (*Client) ListListenersByIpWithChan

func (client *Client) ListListenersByIpWithChan(request *ListListenersByIpRequest) (<-chan *ListListenersByIpResponse, <-chan error)

ListListenersByIpWithChan invokes the mse.ListListenersByIp API asynchronously

func (*Client) ListNacosConfigs

func (client *Client) ListNacosConfigs(request *ListNacosConfigsRequest) (response *ListNacosConfigsResponse, err error)

ListNacosConfigs invokes the mse.ListNacosConfigs API synchronously

func (*Client) ListNacosConfigsWithCallback

func (client *Client) ListNacosConfigsWithCallback(request *ListNacosConfigsRequest, callback func(response *ListNacosConfigsResponse, err error)) <-chan int

ListNacosConfigsWithCallback invokes the mse.ListNacosConfigs API asynchronously

func (*Client) ListNacosConfigsWithChan

func (client *Client) ListNacosConfigsWithChan(request *ListNacosConfigsRequest) (<-chan *ListNacosConfigsResponse, <-chan error)

ListNacosConfigsWithChan invokes the mse.ListNacosConfigs API asynchronously

func (*Client) ListNacosHistoryConfigs

func (client *Client) ListNacosHistoryConfigs(request *ListNacosHistoryConfigsRequest) (response *ListNacosHistoryConfigsResponse, err error)

ListNacosHistoryConfigs invokes the mse.ListNacosHistoryConfigs API synchronously

func (*Client) ListNacosHistoryConfigsWithCallback

func (client *Client) ListNacosHistoryConfigsWithCallback(request *ListNacosHistoryConfigsRequest, callback func(response *ListNacosHistoryConfigsResponse, err error)) <-chan int

ListNacosHistoryConfigsWithCallback invokes the mse.ListNacosHistoryConfigs API asynchronously

func (*Client) ListNacosHistoryConfigsWithChan

func (client *Client) ListNacosHistoryConfigsWithChan(request *ListNacosHistoryConfigsRequest) (<-chan *ListNacosHistoryConfigsResponse, <-chan error)

ListNacosHistoryConfigsWithChan invokes the mse.ListNacosHistoryConfigs API asynchronously

func (*Client) ListZnodeChildren

func (client *Client) ListZnodeChildren(request *ListZnodeChildrenRequest) (response *ListZnodeChildrenResponse, err error)

ListZnodeChildren invokes the mse.ListZnodeChildren API synchronously

func (*Client) ListZnodeChildrenWithCallback

func (client *Client) ListZnodeChildrenWithCallback(request *ListZnodeChildrenRequest, callback func(response *ListZnodeChildrenResponse, err error)) <-chan int

ListZnodeChildrenWithCallback invokes the mse.ListZnodeChildren API asynchronously

func (*Client) ListZnodeChildrenWithChan

func (client *Client) ListZnodeChildrenWithChan(request *ListZnodeChildrenRequest) (<-chan *ListZnodeChildrenResponse, <-chan error)

ListZnodeChildrenWithChan invokes the mse.ListZnodeChildren API asynchronously

func (*Client) QueryBusinessLocations

func (client *Client) QueryBusinessLocations(request *QueryBusinessLocationsRequest) (response *QueryBusinessLocationsResponse, err error)

QueryBusinessLocations invokes the mse.QueryBusinessLocations API synchronously

func (*Client) QueryBusinessLocationsWithCallback

func (client *Client) QueryBusinessLocationsWithCallback(request *QueryBusinessLocationsRequest, callback func(response *QueryBusinessLocationsResponse, err error)) <-chan int

QueryBusinessLocationsWithCallback invokes the mse.QueryBusinessLocations API asynchronously

func (*Client) QueryBusinessLocationsWithChan

func (client *Client) QueryBusinessLocationsWithChan(request *QueryBusinessLocationsRequest) (<-chan *QueryBusinessLocationsResponse, <-chan error)

QueryBusinessLocationsWithChan invokes the mse.QueryBusinessLocations API asynchronously

func (*Client) QueryClusterDetail

func (client *Client) QueryClusterDetail(request *QueryClusterDetailRequest) (response *QueryClusterDetailResponse, err error)

QueryClusterDetail invokes the mse.QueryClusterDetail API synchronously

func (*Client) QueryClusterDetailWithCallback

func (client *Client) QueryClusterDetailWithCallback(request *QueryClusterDetailRequest, callback func(response *QueryClusterDetailResponse, err error)) <-chan int

QueryClusterDetailWithCallback invokes the mse.QueryClusterDetail API asynchronously

func (*Client) QueryClusterDetailWithChan

func (client *Client) QueryClusterDetailWithChan(request *QueryClusterDetailRequest) (<-chan *QueryClusterDetailResponse, <-chan error)

QueryClusterDetailWithChan invokes the mse.QueryClusterDetail API asynchronously

func (*Client) QueryClusterDiskSpecification added in v1.61.998

func (client *Client) QueryClusterDiskSpecification(request *QueryClusterDiskSpecificationRequest) (response *QueryClusterDiskSpecificationResponse, err error)

QueryClusterDiskSpecification invokes the mse.QueryClusterDiskSpecification API synchronously

func (*Client) QueryClusterDiskSpecificationWithCallback added in v1.61.998

func (client *Client) QueryClusterDiskSpecificationWithCallback(request *QueryClusterDiskSpecificationRequest, callback func(response *QueryClusterDiskSpecificationResponse, err error)) <-chan int

QueryClusterDiskSpecificationWithCallback invokes the mse.QueryClusterDiskSpecification API asynchronously

func (*Client) QueryClusterDiskSpecificationWithChan added in v1.61.998

func (client *Client) QueryClusterDiskSpecificationWithChan(request *QueryClusterDiskSpecificationRequest) (<-chan *QueryClusterDiskSpecificationResponse, <-chan error)

QueryClusterDiskSpecificationWithChan invokes the mse.QueryClusterDiskSpecification API asynchronously

func (*Client) QueryClusterSpecification

func (client *Client) QueryClusterSpecification(request *QueryClusterSpecificationRequest) (response *QueryClusterSpecificationResponse, err error)

QueryClusterSpecification invokes the mse.QueryClusterSpecification API synchronously

func (*Client) QueryClusterSpecificationWithCallback

func (client *Client) QueryClusterSpecificationWithCallback(request *QueryClusterSpecificationRequest, callback func(response *QueryClusterSpecificationResponse, err error)) <-chan int

QueryClusterSpecificationWithCallback invokes the mse.QueryClusterSpecification API asynchronously

func (*Client) QueryClusterSpecificationWithChan

func (client *Client) QueryClusterSpecificationWithChan(request *QueryClusterSpecificationRequest) (<-chan *QueryClusterSpecificationResponse, <-chan error)

QueryClusterSpecificationWithChan invokes the mse.QueryClusterSpecification API asynchronously

func (*Client) QueryConfig

func (client *Client) QueryConfig(request *QueryConfigRequest) (response *QueryConfigResponse, err error)

QueryConfig invokes the mse.QueryConfig API synchronously

func (*Client) QueryConfigWithCallback

func (client *Client) QueryConfigWithCallback(request *QueryConfigRequest, callback func(response *QueryConfigResponse, err error)) <-chan int

QueryConfigWithCallback invokes the mse.QueryConfig API asynchronously

func (*Client) QueryConfigWithChan

func (client *Client) QueryConfigWithChan(request *QueryConfigRequest) (<-chan *QueryConfigResponse, <-chan error)

QueryConfigWithChan invokes the mse.QueryConfig API asynchronously

func (*Client) QueryMonitor

func (client *Client) QueryMonitor(request *QueryMonitorRequest) (response *QueryMonitorResponse, err error)

QueryMonitor invokes the mse.QueryMonitor API synchronously

func (*Client) QueryMonitorWithCallback

func (client *Client) QueryMonitorWithCallback(request *QueryMonitorRequest, callback func(response *QueryMonitorResponse, err error)) <-chan int

QueryMonitorWithCallback invokes the mse.QueryMonitor API asynchronously

func (*Client) QueryMonitorWithChan

func (client *Client) QueryMonitorWithChan(request *QueryMonitorRequest) (<-chan *QueryMonitorResponse, <-chan error)

QueryMonitorWithChan invokes the mse.QueryMonitor API asynchronously

func (*Client) QueryZnodeDetail

func (client *Client) QueryZnodeDetail(request *QueryZnodeDetailRequest) (response *QueryZnodeDetailResponse, err error)

QueryZnodeDetail invokes the mse.QueryZnodeDetail API synchronously

func (*Client) QueryZnodeDetailWithCallback

func (client *Client) QueryZnodeDetailWithCallback(request *QueryZnodeDetailRequest, callback func(response *QueryZnodeDetailResponse, err error)) <-chan int

QueryZnodeDetailWithCallback invokes the mse.QueryZnodeDetail API asynchronously

func (*Client) QueryZnodeDetailWithChan

func (client *Client) QueryZnodeDetailWithChan(request *QueryZnodeDetailRequest) (<-chan *QueryZnodeDetailResponse, <-chan error)

QueryZnodeDetailWithChan invokes the mse.QueryZnodeDetail API asynchronously

func (*Client) RestartCluster

func (client *Client) RestartCluster(request *RestartClusterRequest) (response *RestartClusterResponse, err error)

RestartCluster invokes the mse.RestartCluster API synchronously

func (*Client) RestartClusterWithCallback

func (client *Client) RestartClusterWithCallback(request *RestartClusterRequest, callback func(response *RestartClusterResponse, err error)) <-chan int

RestartClusterWithCallback invokes the mse.RestartCluster API asynchronously

func (*Client) RestartClusterWithChan

func (client *Client) RestartClusterWithChan(request *RestartClusterRequest) (<-chan *RestartClusterResponse, <-chan error)

RestartClusterWithChan invokes the mse.RestartCluster API asynchronously

func (*Client) RetryCluster

func (client *Client) RetryCluster(request *RetryClusterRequest) (response *RetryClusterResponse, err error)

RetryCluster invokes the mse.RetryCluster API synchronously

func (*Client) RetryClusterWithCallback

func (client *Client) RetryClusterWithCallback(request *RetryClusterRequest, callback func(response *RetryClusterResponse, err error)) <-chan int

RetryClusterWithCallback invokes the mse.RetryCluster API asynchronously

func (*Client) RetryClusterWithChan

func (client *Client) RetryClusterWithChan(request *RetryClusterRequest) (<-chan *RetryClusterResponse, <-chan error)

RetryClusterWithChan invokes the mse.RetryCluster API asynchronously

func (*Client) ScalingCluster

func (client *Client) ScalingCluster(request *ScalingClusterRequest) (response *ScalingClusterResponse, err error)

ScalingCluster invokes the mse.ScalingCluster API synchronously

func (*Client) ScalingClusterWithCallback

func (client *Client) ScalingClusterWithCallback(request *ScalingClusterRequest, callback func(response *ScalingClusterResponse, err error)) <-chan int

ScalingClusterWithCallback invokes the mse.ScalingCluster API asynchronously

func (*Client) ScalingClusterWithChan

func (client *Client) ScalingClusterWithChan(request *ScalingClusterRequest) (<-chan *ScalingClusterResponse, <-chan error)

ScalingClusterWithChan invokes the mse.ScalingCluster API asynchronously

func (*Client) UpdateAcl

func (client *Client) UpdateAcl(request *UpdateAclRequest) (response *UpdateAclResponse, err error)

UpdateAcl invokes the mse.UpdateAcl API synchronously

func (*Client) UpdateAclWithCallback

func (client *Client) UpdateAclWithCallback(request *UpdateAclRequest, callback func(response *UpdateAclResponse, err error)) <-chan int

UpdateAclWithCallback invokes the mse.UpdateAcl API asynchronously

func (*Client) UpdateAclWithChan

func (client *Client) UpdateAclWithChan(request *UpdateAclRequest) (<-chan *UpdateAclResponse, <-chan error)

UpdateAclWithChan invokes the mse.UpdateAcl API asynchronously

func (*Client) UpdateCluster

func (client *Client) UpdateCluster(request *UpdateClusterRequest) (response *UpdateClusterResponse, err error)

UpdateCluster invokes the mse.UpdateCluster API synchronously

func (*Client) UpdateClusterWithCallback

func (client *Client) UpdateClusterWithCallback(request *UpdateClusterRequest, callback func(response *UpdateClusterResponse, err error)) <-chan int

UpdateClusterWithCallback invokes the mse.UpdateCluster API asynchronously

func (*Client) UpdateClusterWithChan

func (client *Client) UpdateClusterWithChan(request *UpdateClusterRequest) (<-chan *UpdateClusterResponse, <-chan error)

UpdateClusterWithChan invokes the mse.UpdateCluster API asynchronously

func (*Client) UpdateConfig

func (client *Client) UpdateConfig(request *UpdateConfigRequest) (response *UpdateConfigResponse, err error)

UpdateConfig invokes the mse.UpdateConfig API synchronously

func (*Client) UpdateConfigWithCallback

func (client *Client) UpdateConfigWithCallback(request *UpdateConfigRequest, callback func(response *UpdateConfigResponse, err error)) <-chan int

UpdateConfigWithCallback invokes the mse.UpdateConfig API asynchronously

func (*Client) UpdateConfigWithChan

func (client *Client) UpdateConfigWithChan(request *UpdateConfigRequest) (<-chan *UpdateConfigResponse, <-chan error)

UpdateConfigWithChan invokes the mse.UpdateConfig API asynchronously

func (*Client) UpdateEngineNamespace

func (client *Client) UpdateEngineNamespace(request *UpdateEngineNamespaceRequest) (response *UpdateEngineNamespaceResponse, err error)

UpdateEngineNamespace invokes the mse.UpdateEngineNamespace API synchronously

func (*Client) UpdateEngineNamespaceWithCallback

func (client *Client) UpdateEngineNamespaceWithCallback(request *UpdateEngineNamespaceRequest, callback func(response *UpdateEngineNamespaceResponse, err error)) <-chan int

UpdateEngineNamespaceWithCallback invokes the mse.UpdateEngineNamespace API asynchronously

func (*Client) UpdateEngineNamespaceWithChan

func (client *Client) UpdateEngineNamespaceWithChan(request *UpdateEngineNamespaceRequest) (<-chan *UpdateEngineNamespaceResponse, <-chan error)

UpdateEngineNamespaceWithChan invokes the mse.UpdateEngineNamespace API asynchronously

func (*Client) UpdateNacosConfig

func (client *Client) UpdateNacosConfig(request *UpdateNacosConfigRequest) (response *UpdateNacosConfigResponse, err error)

UpdateNacosConfig invokes the mse.UpdateNacosConfig API synchronously

func (*Client) UpdateNacosConfigWithCallback

func (client *Client) UpdateNacosConfigWithCallback(request *UpdateNacosConfigRequest, callback func(response *UpdateNacosConfigResponse, err error)) <-chan int

UpdateNacosConfigWithCallback invokes the mse.UpdateNacosConfig API asynchronously

func (*Client) UpdateNacosConfigWithChan

func (client *Client) UpdateNacosConfigWithChan(request *UpdateNacosConfigRequest) (<-chan *UpdateNacosConfigResponse, <-chan error)

UpdateNacosConfigWithChan invokes the mse.UpdateNacosConfig API asynchronously

func (*Client) UpdateNacosInstance added in v1.61.998

func (client *Client) UpdateNacosInstance(request *UpdateNacosInstanceRequest) (response *UpdateNacosInstanceResponse, err error)

UpdateNacosInstance invokes the mse.UpdateNacosInstance API synchronously

func (*Client) UpdateNacosInstanceWithCallback added in v1.61.998

func (client *Client) UpdateNacosInstanceWithCallback(request *UpdateNacosInstanceRequest, callback func(response *UpdateNacosInstanceResponse, err error)) <-chan int

UpdateNacosInstanceWithCallback invokes the mse.UpdateNacosInstance API asynchronously

func (*Client) UpdateNacosInstanceWithChan added in v1.61.998

func (client *Client) UpdateNacosInstanceWithChan(request *UpdateNacosInstanceRequest) (<-chan *UpdateNacosInstanceResponse, <-chan error)

UpdateNacosInstanceWithChan invokes the mse.UpdateNacosInstance API asynchronously

func (*Client) UpdateZnode

func (client *Client) UpdateZnode(request *UpdateZnodeRequest) (response *UpdateZnodeResponse, err error)

UpdateZnode invokes the mse.UpdateZnode API synchronously

func (*Client) UpdateZnodeWithCallback

func (client *Client) UpdateZnodeWithCallback(request *UpdateZnodeRequest, callback func(response *UpdateZnodeResponse, err error)) <-chan int

UpdateZnodeWithCallback invokes the mse.UpdateZnode API asynchronously

func (*Client) UpdateZnodeWithChan

func (client *Client) UpdateZnodeWithChan(request *UpdateZnodeRequest) (<-chan *UpdateZnodeResponse, <-chan error)

UpdateZnodeWithChan invokes the mse.UpdateZnode API asynchronously

func (*Client) UpgradeCluster

func (client *Client) UpgradeCluster(request *UpgradeClusterRequest) (response *UpgradeClusterResponse, err error)

UpgradeCluster invokes the mse.UpgradeCluster API synchronously

func (*Client) UpgradeClusterWithCallback

func (client *Client) UpgradeClusterWithCallback(request *UpgradeClusterRequest, callback func(response *UpgradeClusterResponse, err error)) <-chan int

UpgradeClusterWithCallback invokes the mse.UpgradeCluster API asynchronously

func (*Client) UpgradeClusterWithChan

func (client *Client) UpgradeClusterWithChan(request *UpgradeClusterRequest) (<-chan *UpgradeClusterResponse, <-chan error)

UpgradeClusterWithChan invokes the mse.UpgradeCluster API asynchronously

type CloneNacosConfigRequest added in v1.61.998

type CloneNacosConfigRequest struct {
	*requests.RpcRequest
	TargetNamespaceId string `position:"Query" name:"TargetNamespaceId"`
	InstanceId        string `position:"Query" name:"InstanceId"`
	Ids               string `position:"Query" name:"Ids"`
	OriginNamespaceId string `position:"Query" name:"OriginNamespaceId"`
	Policy            string `position:"Query" name:"Policy"`
}

CloneNacosConfigRequest is the request struct for api CloneNacosConfig

func CreateCloneNacosConfigRequest added in v1.61.998

func CreateCloneNacosConfigRequest() (request *CloneNacosConfigRequest)

CreateCloneNacosConfigRequest creates a request to invoke CloneNacosConfig API

type CloneNacosConfigResponse added in v1.61.998

type CloneNacosConfigResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Message        string `json:"Message" xml:"Message"`
	ErrorCode      string `json:"ErrorCode" xml:"ErrorCode"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code           int    `json:"Code" xml:"Code"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	Data           Data   `json:"Data" xml:"Data"`
}

CloneNacosConfigResponse is the response struct for api CloneNacosConfig

func CreateCloneNacosConfigResponse added in v1.61.998

func CreateCloneNacosConfigResponse() (response *CloneNacosConfigResponse)

CreateCloneNacosConfigResponse creates a response to parse from CloneNacosConfig response

type ClusterForListModel

type ClusterForListModel struct {
	AppVersion       string `json:"AppVersion" xml:"AppVersion"`
	ClusterAliasName string `json:"ClusterAliasName" xml:"ClusterAliasName"`
	InternetAddress  string `json:"InternetAddress" xml:"InternetAddress"`
	IntranetAddress  string `json:"IntranetAddress" xml:"IntranetAddress"`
	ClusterId        string `json:"ClusterId" xml:"ClusterId"`
	InstanceId       string `json:"InstanceId" xml:"InstanceId"`
	ChargeType       string `json:"ChargeType" xml:"ChargeType"`
	InternetDomain   string `json:"InternetDomain" xml:"InternetDomain"`
	CreateTime       string `json:"CreateTime" xml:"CreateTime"`
	InitStatus       string `json:"InitStatus" xml:"InitStatus"`
	ClusterType      string `json:"ClusterType" xml:"ClusterType"`
	IntranetDomain   string `json:"IntranetDomain" xml:"IntranetDomain"`
	EndDate          string `json:"EndDate" xml:"EndDate"`
}

ClusterForListModel is a nested struct in mse response

type Clusters

type Clusters struct {
	NacosAnsCluster []NacosAnsCluster `json:"NacosAnsCluster" xml:"NacosAnsCluster"`
}

Clusters is a nested struct in mse response

type Configuration

type Configuration struct {
	Tags    string `json:"Tags" xml:"Tags"`
	DataId  string `json:"DataId" xml:"DataId"`
	Group   string `json:"Group" xml:"Group"`
	Desc    string `json:"Desc" xml:"Desc"`
	Content string `json:"Content" xml:"Content"`
	OpType  string `json:"OpType" xml:"OpType"`
	Md5     string `json:"Md5" xml:"Md5"`
	AppName string `json:"AppName" xml:"AppName"`
	Type    string `json:"Type" xml:"Type"`
}

Configuration is a nested struct in mse response

type Configurations

type Configurations struct {
	NacosConfigForListModel []NacosConfigForListModel `json:"NacosConfigForListModel" xml:"NacosConfigForListModel"`
}

Configurations is a nested struct in mse response

type CreateAlarmRuleRequest

type CreateAlarmRuleRequest struct {
	*requests.RpcRequest
	NValue          requests.Integer `position:"Query" name:"NValue"`
	AlarmItem       string           `position:"Query" name:"AlarmItem"`
	ClusterId       string           `position:"Query" name:"ClusterId"`
	Operator        string           `position:"Query" name:"Operator"`
	AlarmAliasName  string           `position:"Query" name:"AlarmAliasName"`
	InstanceId      string           `position:"Query" name:"InstanceId"`
	ContactGroupIds string           `position:"Query" name:"ContactGroupIds"`
	AlertWay        string           `position:"Query" name:"AlertWay"`
	Aggregates      string           `position:"Query" name:"Aggregates"`
	Value           requests.Float   `position:"Query" name:"Value"`
}

CreateAlarmRuleRequest is the request struct for api CreateAlarmRule

func CreateCreateAlarmRuleRequest

func CreateCreateAlarmRuleRequest() (request *CreateAlarmRuleRequest)

CreateCreateAlarmRuleRequest creates a request to invoke CreateAlarmRule API

type CreateAlarmRuleResponse

type CreateAlarmRuleResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
}

CreateAlarmRuleResponse is the response struct for api CreateAlarmRule

func CreateCreateAlarmRuleResponse

func CreateCreateAlarmRuleResponse() (response *CreateAlarmRuleResponse)

CreateCreateAlarmRuleResponse creates a response to parse from CreateAlarmRule response

type CreateApplicationRequest added in v1.61.1002

type CreateApplicationRequest struct {
	*requests.RpcRequest
	Language  string `position:"Query" name:"Language"`
	Source    string `position:"Query" name:"Source"`
	ExtraInfo string `position:"Query" name:"ExtraInfo"`
	AppName   string `position:"Query" name:"AppName"`
	Region    string `position:"Query" name:"Region"`
}

CreateApplicationRequest is the request struct for api CreateApplication

func CreateCreateApplicationRequest added in v1.61.1002

func CreateCreateApplicationRequest() (request *CreateApplicationRequest)

CreateCreateApplicationRequest creates a request to invoke CreateApplication API

type CreateApplicationResponse added in v1.61.1002

type CreateApplicationResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code           int    `json:"Code" xml:"Code"`
	Success        string `json:"Success" xml:"Success"`
	Data           Data   `json:"Data" xml:"Data"`
}

CreateApplicationResponse is the response struct for api CreateApplication

func CreateCreateApplicationResponse added in v1.61.1002

func CreateCreateApplicationResponse() (response *CreateApplicationResponse)

CreateCreateApplicationResponse creates a response to parse from CreateApplication response

type CreateClusterRequest

type CreateClusterRequest struct {
	*requests.RpcRequest
	ClusterSpecification    string           `position:"Query" name:"ClusterSpecification"`
	PubSlbSpecification     string           `position:"Query" name:"PubSlbSpecification"`
	PrivateSlbSpecification string           `position:"Query" name:"PrivateSlbSpecification"`
	InstanceCount           requests.Integer `position:"Query" name:"InstanceCount"`
	RequestPars             string           `position:"Query" name:"RequestPars"`
	ConnectionType          string           `position:"Query" name:"ConnectionType"`
	ClusterVersion          string           `position:"Query" name:"ClusterVersion"`
	DiskCapacity            requests.Integer `position:"Query" name:"DiskCapacity"`
	DiskType                string           `position:"Query" name:"DiskType"`
	VSwitchId               string           `position:"Query" name:"VSwitchId"`
	ClusterType             string           `position:"Query" name:"ClusterType"`
	PubNetworkFlow          string           `position:"Query" name:"PubNetworkFlow"`
	VpcId                   string           `position:"Query" name:"VpcId"`
	NetType                 string           `position:"Query" name:"NetType"`
	Region                  string           `position:"Query" name:"Region"`
}

CreateClusterRequest is the request struct for api CreateCluster

func CreateCreateClusterRequest

func CreateCreateClusterRequest() (request *CreateClusterRequest)

CreateCreateClusterRequest creates a request to invoke CreateCluster API

type CreateClusterResponse

type CreateClusterResponse struct {
	*responses.BaseResponse
	Message    string `json:"Message" xml:"Message"`
	RequestId  string `json:"RequestId" xml:"RequestId"`
	InstanceId string `json:"InstanceId" xml:"InstanceId"`
	ErrorCode  string `json:"ErrorCode" xml:"ErrorCode"`
	OrderId    string `json:"OrderId" xml:"OrderId"`
	Success    bool   `json:"Success" xml:"Success"`
}

CreateClusterResponse is the response struct for api CreateCluster

func CreateCreateClusterResponse

func CreateCreateClusterResponse() (response *CreateClusterResponse)

CreateCreateClusterResponse creates a response to parse from CreateCluster response

type CreateEngineNamespaceRequest

type CreateEngineNamespaceRequest struct {
	*requests.RpcRequest
	ClusterId    string           `position:"Query" name:"ClusterId"`
	InstanceId   string           `position:"Query" name:"InstanceId"`
	ServiceCount requests.Integer `position:"Query" name:"ServiceCount"`
	Name         string           `position:"Query" name:"Name"`
	Desc         string           `position:"Query" name:"Desc"`
}

CreateEngineNamespaceRequest is the request struct for api CreateEngineNamespace

func CreateCreateEngineNamespaceRequest

func CreateCreateEngineNamespaceRequest() (request *CreateEngineNamespaceRequest)

CreateCreateEngineNamespaceRequest creates a request to invoke CreateEngineNamespace API

type CreateEngineNamespaceResponse

type CreateEngineNamespaceResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	ClusterId string `json:"ClusterId" xml:"ClusterId"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

CreateEngineNamespaceResponse is the response struct for api CreateEngineNamespace

func CreateCreateEngineNamespaceResponse

func CreateCreateEngineNamespaceResponse() (response *CreateEngineNamespaceResponse)

CreateCreateEngineNamespaceResponse creates a response to parse from CreateEngineNamespace response

type CreateNacosConfigRequest

type CreateNacosConfigRequest struct {
	*requests.RpcRequest
	Type        string `position:"Query" name:"Type"`
	Content     string `position:"Query" name:"Content"`
	Tags        string `position:"Query" name:"Tags"`
	InstanceId  string `position:"Query" name:"InstanceId"`
	DataId      string `position:"Query" name:"DataId"`
	AppName     string `position:"Query" name:"AppName"`
	NamespaceId string `position:"Query" name:"NamespaceId"`
	Group       string `position:"Query" name:"Group"`
	Desc        string `position:"Query" name:"Desc"`
}

CreateNacosConfigRequest is the request struct for api CreateNacosConfig

func CreateCreateNacosConfigRequest

func CreateCreateNacosConfigRequest() (request *CreateNacosConfigRequest)

CreateCreateNacosConfigRequest creates a request to invoke CreateNacosConfig API

type CreateNacosConfigResponse

type CreateNacosConfigResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	HttpCode  string `json:"HttpCode" xml:"HttpCode"`
	Code      string `json:"Code" xml:"Code"`
}

CreateNacosConfigResponse is the response struct for api CreateNacosConfig

func CreateCreateNacosConfigResponse

func CreateCreateNacosConfigResponse() (response *CreateNacosConfigResponse)

CreateCreateNacosConfigResponse creates a response to parse from CreateNacosConfig response

type CreateZnodeRequest

type CreateZnodeRequest struct {
	*requests.RpcRequest
	Data      string `position:"Query" name:"Data"`
	ClusterId string `position:"Query" name:"ClusterId"`
	Path      string `position:"Query" name:"Path"`
}

CreateZnodeRequest is the request struct for api CreateZnode

func CreateCreateZnodeRequest

func CreateCreateZnodeRequest() (request *CreateZnodeRequest)

CreateCreateZnodeRequest creates a request to invoke CreateZnode API

type CreateZnodeResponse

type CreateZnodeResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	HttpCode  string `json:"HttpCode" xml:"HttpCode"`
	Data      Data   `json:"Data" xml:"Data"`
}

CreateZnodeResponse is the response struct for api CreateZnode

func CreateCreateZnodeResponse

func CreateCreateZnodeResponse() (response *CreateZnodeResponse)

CreateCreateZnodeResponse creates a response to parse from CreateZnode response

type Data

type Data struct {
	Step                     int                    `json:"Step" xml:"Step"`
	ExtraJson                string                 `json:"ExtraJson" xml:"ExtraJson"`
	Dir                      bool                   `json:"Dir" xml:"Dir"`
	Source                   string                 `json:"Source" xml:"Source"`
	ConfigAuthEnabled        bool                   `json:"ConfigAuthEnabled" xml:"ConfigAuthEnabled"`
	JuteMaxbuffer            string                 `json:"JuteMaxbuffer" xml:"JuteMaxbuffer"`
	ConsumerAppName          string                 `json:"ConsumerAppName" xml:"ConsumerAppName"`
	InitLimit                string                 `json:"InitLimit" xml:"InitLimit"`
	Path                     string                 `json:"Path" xml:"Path"`
	LicenseKey               string                 `json:"LicenseKey" xml:"LicenseKey"`
	SyncLimit                string                 `json:"SyncLimit" xml:"SyncLimit"`
	UpdateTime               int64                  `json:"UpdateTime" xml:"UpdateTime"`
	NamespaceDesc            string                 `json:"NamespaceDesc" xml:"NamespaceDesc"`
	Data                     string                 `json:"Data" xml:"Data"`
	ProtectThreshold         float64                `json:"ProtectThreshold" xml:"ProtectThreshold"`
	MCPSupported             bool                   `json:"MCPSupported" xml:"MCPSupported"`
	ProviderAppName          string                 `json:"ProviderAppName" xml:"ProviderAppName"`
	Id                       int64                  `json:"Id" xml:"Id"`
	JvmFlagsCustom           string                 `json:"JvmFlagsCustom" xml:"JvmFlagsCustom"`
	AppId                    string                 `json:"AppId" xml:"AppId"`
	AccountId                string                 `json:"AccountId" xml:"AccountId"`
	Metadata                 map[string]interface{} `json:"Metadata" xml:"Metadata"`
	Enable                   bool                   `json:"Enable" xml:"Enable"`
	ServiceCount             int                    `json:"ServiceCount" xml:"ServiceCount"`
	SuccCount                int                    `json:"SuccCount" xml:"SuccCount"`
	AutopurgePurgeInterval   string                 `json:"AutopurgePurgeInterval" xml:"AutopurgePurgeInterval"`
	SelectorType             string                 `json:"SelectorType" xml:"SelectorType"`
	Type                     int                    `json:"Type" xml:"Type"`
	Region                   string                 `json:"Region" xml:"Region"`
	Name                     string                 `json:"Name" xml:"Name"`
	Max                      int                    `json:"Max" xml:"Max"`
	Language                 string                 `json:"Language" xml:"Language"`
	GroupName                string                 `json:"GroupName" xml:"GroupName"`
	CreateTime               int64                  `json:"CreateTime" xml:"CreateTime"`
	MaxClientCnxns           string                 `json:"MaxClientCnxns" xml:"MaxClientCnxns"`
	ExtraInfo                string                 `json:"ExtraInfo" xml:"ExtraInfo"`
	MCPEnabled               bool                   `json:"MCPEnabled" xml:"MCPEnabled"`
	ConsumerAppId            string                 `json:"ConsumerAppId" xml:"ConsumerAppId"`
	RegionId                 string                 `json:"RegionId" xml:"RegionId"`
	UserId                   string                 `json:"UserId" xml:"UserId"`
	ConfigCount              int                    `json:"ConfigCount" xml:"ConfigCount"`
	ClusterName              string                 `json:"ClusterName" xml:"ClusterName"`
	PassWord                 string                 `json:"PassWord" xml:"PassWord"`
	NamespaceShowName        string                 `json:"NamespaceShowName" xml:"NamespaceShowName"`
	Min                      int                    `json:"Min" xml:"Min"`
	OpenSuperAcl             bool                   `json:"OpenSuperAcl" xml:"OpenSuperAcl"`
	Status                   int                    `json:"Status" xml:"Status"`
	SkipCount                int                    `json:"SkipCount" xml:"SkipCount"`
	AutopurgeSnapRetainCount string                 `json:"AutopurgeSnapRetainCount" xml:"AutopurgeSnapRetainCount"`
	TickTime                 string                 `json:"TickTime" xml:"TickTime"`
	Quota                    int                    `json:"Quota" xml:"Quota"`
	Url                      string                 `json:"Url" xml:"Url"`
	ScMockItemJson           string                 `json:"ScMockItemJson" xml:"ScMockItemJson"`
	RestartFlag              bool                   `json:"RestartFlag" xml:"RestartFlag"`
	Namespace                string                 `json:"Namespace" xml:"Namespace"`
	NamespaceId              string                 `json:"NamespaceId" xml:"NamespaceId"`
	UserName                 string                 `json:"UserName" xml:"UserName"`
	ProviderAppId            string                 `json:"ProviderAppId" xml:"ProviderAppId"`
	AppName                  string                 `json:"AppName" xml:"AppName"`
	ConfigAuthSupported      bool                   `json:"ConfigAuthSupported" xml:"ConfigAuthSupported"`
	FailData                 []FailDataItem         `json:"FailData" xml:"FailData"`
	Clusters                 []NacosAnsCluster      `json:"Clusters" xml:"Clusters"`
	SkipData                 []SkipDataItem         `json:"SkipData" xml:"SkipData"`
}

Data is a nested struct in mse response

type DataInListAlarmContactGroups

type DataInListAlarmContactGroups struct {
	AlarmContactGroupModel []AlarmContactGroupModel `json:"AlarmContactGroupModel" xml:"AlarmContactGroupModel"`
}

DataInListAlarmContactGroups is a nested struct in mse response

type DataInListAlarmHistories

type DataInListAlarmHistories struct {
	AlarmHistoryModel []AlarmHistoryModel `json:"AlarmHistoryModel" xml:"AlarmHistoryModel"`
}

DataInListAlarmHistories is a nested struct in mse response

type DataInListAlarmItems

type DataInListAlarmItems struct {
	AlarmItem []AlarmItem `json:"AlarmItem" xml:"AlarmItem"`
}

DataInListAlarmItems is a nested struct in mse response

type DataInListAlarmRules

type DataInListAlarmRules struct {
	AlarmRuleModel []AlarmRuleModel `json:"AlarmRuleModel" xml:"AlarmRuleModel"`
}

DataInListAlarmRules is a nested struct in mse response

type DataInListAnsInstances

type DataInListAnsInstances struct {
	NacosAnsInstance []NacosAnsInstance `json:"NacosAnsInstance" xml:"NacosAnsInstance"`
}

DataInListAnsInstances is a nested struct in mse response

type DataInListAnsServices

type DataInListAnsServices struct {
	SimpleNacosAnsService []SimpleNacosAnsService `json:"SimpleNacosAnsService" xml:"SimpleNacosAnsService"`
}

DataInListAnsServices is a nested struct in mse response

type DataInListClusterConnectionTypes added in v1.61.998

type DataInListClusterConnectionTypes struct {
	DataItem []DataItem `json:"Data" xml:"Data"`
}

DataInListClusterConnectionTypes is a nested struct in mse response

type DataInListClusterTypes added in v1.61.998

type DataInListClusterTypes struct {
	DataItem []DataItem `json:"Data" xml:"Data"`
}

DataInListClusterTypes is a nested struct in mse response

type DataInListClusterVersions added in v1.61.998

type DataInListClusterVersions struct {
	DataItem []DataItem `json:"Data" xml:"Data"`
}

DataInListClusterVersions is a nested struct in mse response

type DataInListClusters

type DataInListClusters struct {
	ClusterForListModel []ClusterForListModel `json:"ClusterForListModel" xml:"ClusterForListModel"`
}

DataInListClusters is a nested struct in mse response

type DataInListEngineNamespaces

type DataInListEngineNamespaces struct {
	Namespace []Namespace `json:"Namespace" xml:"Namespace"`
}

DataInListEngineNamespaces is a nested struct in mse response

type DataInListEurekaInstances

type DataInListEurekaInstances struct {
	EurekaInstance []EurekaInstance `json:"EurekaInstance" xml:"EurekaInstance"`
}

DataInListEurekaInstances is a nested struct in mse response

type DataInListEurekaServices

type DataInListEurekaServices struct {
	SimpleService []SimpleService `json:"SimpleService" xml:"SimpleService"`
}

DataInListEurekaServices is a nested struct in mse response

type DataInListZnodeChildren

type DataInListZnodeChildren struct {
	ZnodeModel []ZnodeModel `json:"ZnodeModel" xml:"ZnodeModel"`
}

DataInListZnodeChildren is a nested struct in mse response

type DataInQueryBusinessLocations

type DataInQueryBusinessLocations struct {
	LocationData []LocationData `json:"LocationData" xml:"LocationData"`
}

DataInQueryBusinessLocations is a nested struct in mse response

type DataInQueryClusterDetail added in v1.61.1002

type DataInQueryClusterDetail struct {
	InternetAddress      string          `json:"InternetAddress" xml:"InternetAddress"`
	AclEntryList         string          `json:"AclEntryList" xml:"AclEntryList"`
	Cpu                  int             `json:"Cpu" xml:"Cpu"`
	InternetPort         string          `json:"InternetPort" xml:"InternetPort"`
	IntranetPort         string          `json:"IntranetPort" xml:"IntranetPort"`
	AppVersion           string          `json:"AppVersion" xml:"AppVersion"`
	DiskType             string          `json:"DiskType" xml:"DiskType"`
	InitCostTime         int64           `json:"InitCostTime" xml:"InitCostTime"`
	PayInfo              string          `json:"PayInfo" xml:"PayInfo"`
	ClusterName          string          `json:"ClusterName" xml:"ClusterName"`
	IntranetDomain       string          `json:"IntranetDomain" xml:"IntranetDomain"`
	NetType              string          `json:"NetType" xml:"NetType"`
	ConnectionType       string          `json:"ConnectionType" xml:"ConnectionType"`
	ClusterVersion       string          `json:"ClusterVersion" xml:"ClusterVersion"`
	InstanceId           string          `json:"InstanceId" xml:"InstanceId"`
	ClusterId            string          `json:"ClusterId" xml:"ClusterId"`
	InternetDomain       string          `json:"InternetDomain" xml:"InternetDomain"`
	VSwitchId            string          `json:"VSwitchId" xml:"VSwitchId"`
	ClusterSpecification string          `json:"ClusterSpecification" xml:"ClusterSpecification"`
	AclId                string          `json:"AclId" xml:"AclId"`
	CreateTime           string          `json:"CreateTime" xml:"CreateTime"`
	HealthStatus         string          `json:"HealthStatus" xml:"HealthStatus"`
	ClusterType          string          `json:"ClusterType" xml:"ClusterType"`
	MemoryCapacity       int64           `json:"MemoryCapacity" xml:"MemoryCapacity"`
	ClusterAliasName     string          `json:"ClusterAliasName" xml:"ClusterAliasName"`
	InstanceCount        int             `json:"InstanceCount" xml:"InstanceCount"`
	IntranetAddress      string          `json:"IntranetAddress" xml:"IntranetAddress"`
	DiskCapacity         int64           `json:"DiskCapacity" xml:"DiskCapacity"`
	VpcId                string          `json:"VpcId" xml:"VpcId"`
	PubNetworkFlow       string          `json:"PubNetworkFlow" xml:"PubNetworkFlow"`
	InitStatus           string          `json:"InitStatus" xml:"InitStatus"`
	RegionId             string          `json:"RegionId" xml:"RegionId"`
	InstanceModels       []InstanceModel `json:"InstanceModels" xml:"InstanceModels"`
}

DataInQueryClusterDetail is a nested struct in mse response

type DataInQueryClusterSpecification

type DataInQueryClusterSpecification struct {
	DataItem []DataItem `json:"Data" xml:"Data"`
}

DataInQueryClusterSpecification is a nested struct in mse response

type DataItem added in v1.61.998

type DataItem struct {
	ShowName                 string `json:"ShowName" xml:"ShowName"`
	MaxCon                   string `json:"MaxCon" xml:"MaxCon"`
	ClusterType              string `json:"ClusterType" xml:"ClusterType"`
	CpuCapacity              string `json:"CpuCapacity" xml:"CpuCapacity"`
	MaxTps                   string `json:"MaxTps" xml:"MaxTps"`
	Code                     string `json:"Code" xml:"Code"`
	InstanceCount            string `json:"InstanceCount" xml:"InstanceCount"`
	MemoryCapacity           string `json:"MemoryCapacity" xml:"MemoryCapacity"`
	ClusterSpecificationName string `json:"ClusterSpecificationName" xml:"ClusterSpecificationName"`
	DiskCapacity             string `json:"DiskCapacity" xml:"DiskCapacity"`
}

DataItem is a nested struct in mse response

type DeleteAlarmRuleRequest

type DeleteAlarmRuleRequest struct {
	*requests.RpcRequest
	AlarmRuleId string `position:"Query" name:"AlarmRuleId"`
	RequestPars string `position:"Query" name:"RequestPars"`
}

DeleteAlarmRuleRequest is the request struct for api DeleteAlarmRule

func CreateDeleteAlarmRuleRequest

func CreateDeleteAlarmRuleRequest() (request *DeleteAlarmRuleRequest)

CreateDeleteAlarmRuleRequest creates a request to invoke DeleteAlarmRule API

type DeleteAlarmRuleResponse

type DeleteAlarmRuleResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	HttpCode  string `json:"HttpCode" xml:"HttpCode"`
}

DeleteAlarmRuleResponse is the response struct for api DeleteAlarmRule

func CreateDeleteAlarmRuleResponse

func CreateDeleteAlarmRuleResponse() (response *DeleteAlarmRuleResponse)

CreateDeleteAlarmRuleResponse creates a response to parse from DeleteAlarmRule response

type DeleteClusterRequest

type DeleteClusterRequest struct {
	*requests.RpcRequest
	ClusterId  string `position:"Query" name:"ClusterId"`
	InstanceId string `position:"Query" name:"InstanceId"`
}

DeleteClusterRequest is the request struct for api DeleteCluster

func CreateDeleteClusterRequest

func CreateDeleteClusterRequest() (request *DeleteClusterRequest)

CreateDeleteClusterRequest creates a request to invoke DeleteCluster API

type DeleteClusterResponse

type DeleteClusterResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	HttpCode  string `json:"HttpCode" xml:"HttpCode"`
}

DeleteClusterResponse is the response struct for api DeleteCluster

func CreateDeleteClusterResponse

func CreateDeleteClusterResponse() (response *DeleteClusterResponse)

CreateDeleteClusterResponse creates a response to parse from DeleteCluster response

type DeleteEngineNamespaceRequest

type DeleteEngineNamespaceRequest struct {
	*requests.RpcRequest
	ClusterId  string `position:"Query" name:"ClusterId"`
	InstanceId string `position:"Query" name:"InstanceId"`
	Id         string `position:"Query" name:"Id"`
}

DeleteEngineNamespaceRequest is the request struct for api DeleteEngineNamespace

func CreateDeleteEngineNamespaceRequest

func CreateDeleteEngineNamespaceRequest() (request *DeleteEngineNamespaceRequest)

CreateDeleteEngineNamespaceRequest creates a request to invoke DeleteEngineNamespace API

type DeleteEngineNamespaceResponse

type DeleteEngineNamespaceResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	HttpCode  string `json:"HttpCode" xml:"HttpCode"`
}

DeleteEngineNamespaceResponse is the response struct for api DeleteEngineNamespace

func CreateDeleteEngineNamespaceResponse

func CreateDeleteEngineNamespaceResponse() (response *DeleteEngineNamespaceResponse)

CreateDeleteEngineNamespaceResponse creates a response to parse from DeleteEngineNamespace response

type DeleteNacosConfigRequest

type DeleteNacosConfigRequest struct {
	*requests.RpcRequest
	InstanceId  string `position:"Query" name:"InstanceId"`
	DataId      string `position:"Query" name:"DataId"`
	NamespaceId string `position:"Query" name:"NamespaceId"`
	Group       string `position:"Query" name:"Group"`
}

DeleteNacosConfigRequest is the request struct for api DeleteNacosConfig

func CreateDeleteNacosConfigRequest

func CreateDeleteNacosConfigRequest() (request *DeleteNacosConfigRequest)

CreateDeleteNacosConfigRequest creates a request to invoke DeleteNacosConfig API

type DeleteNacosConfigResponse

type DeleteNacosConfigResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	HttpCode  string `json:"HttpCode" xml:"HttpCode"`
	Code      string `json:"Code" xml:"Code"`
}

DeleteNacosConfigResponse is the response struct for api DeleteNacosConfig

func CreateDeleteNacosConfigResponse

func CreateDeleteNacosConfigResponse() (response *DeleteNacosConfigResponse)

CreateDeleteNacosConfigResponse creates a response to parse from DeleteNacosConfig response

type DeleteNacosConfigsRequest

type DeleteNacosConfigsRequest struct {
	*requests.RpcRequest
	InstanceId  string `position:"Query" name:"InstanceId"`
	NamespaceId string `position:"Query" name:"NamespaceId"`
	Ids         string `position:"Query" name:"Ids"`
}

DeleteNacosConfigsRequest is the request struct for api DeleteNacosConfigs

func CreateDeleteNacosConfigsRequest

func CreateDeleteNacosConfigsRequest() (request *DeleteNacosConfigsRequest)

CreateDeleteNacosConfigsRequest creates a request to invoke DeleteNacosConfigs API

type DeleteNacosConfigsResponse

type DeleteNacosConfigsResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	HttpCode  string `json:"HttpCode" xml:"HttpCode"`
	Code      int    `json:"Code" xml:"Code"`
}

DeleteNacosConfigsResponse is the response struct for api DeleteNacosConfigs

func CreateDeleteNacosConfigsResponse

func CreateDeleteNacosConfigsResponse() (response *DeleteNacosConfigsResponse)

CreateDeleteNacosConfigsResponse creates a response to parse from DeleteNacosConfigs response

type DeleteNacosServiceRequest added in v1.61.998

type DeleteNacosServiceRequest struct {
	*requests.RpcRequest
	GroupName   string `position:"Query" name:"GroupName"`
	InstanceId  string `position:"Query" name:"InstanceId"`
	NamespaceId string `position:"Query" name:"NamespaceId"`
	ServiceName string `position:"Query" name:"ServiceName"`
}

DeleteNacosServiceRequest is the request struct for api DeleteNacosService

func CreateDeleteNacosServiceRequest added in v1.61.998

func CreateDeleteNacosServiceRequest() (request *DeleteNacosServiceRequest)

CreateDeleteNacosServiceRequest creates a request to invoke DeleteNacosService API

type DeleteNacosServiceResponse added in v1.61.998

type DeleteNacosServiceResponse struct {
	*responses.BaseResponse
	Message        string `json:"Message" xml:"Message"`
	RequestId      string `json:"RequestId" xml:"RequestId"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Data           string `json:"Data" xml:"Data"`
	Code           int    `json:"Code" xml:"Code"`
	Success        bool   `json:"Success" xml:"Success"`
}

DeleteNacosServiceResponse is the response struct for api DeleteNacosService

func CreateDeleteNacosServiceResponse added in v1.61.998

func CreateDeleteNacosServiceResponse() (response *DeleteNacosServiceResponse)

CreateDeleteNacosServiceResponse creates a response to parse from DeleteNacosService response

type DeleteZnodeRequest

type DeleteZnodeRequest struct {
	*requests.RpcRequest
	ClusterId   string `position:"Query" name:"ClusterId"`
	Path        string `position:"Query" name:"Path"`
	RequestPars string `position:"Query" name:"RequestPars"`
}

DeleteZnodeRequest is the request struct for api DeleteZnode

func CreateDeleteZnodeRequest

func CreateDeleteZnodeRequest() (request *DeleteZnodeRequest)

CreateDeleteZnodeRequest creates a request to invoke DeleteZnode API

type DeleteZnodeResponse

type DeleteZnodeResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	HttpCode  string `json:"HttpCode" xml:"HttpCode"`
	Data      Data   `json:"Data" xml:"Data"`
}

DeleteZnodeResponse is the response struct for api DeleteZnode

func CreateDeleteZnodeResponse

func CreateDeleteZnodeResponse() (response *DeleteZnodeResponse)

CreateDeleteZnodeResponse creates a response to parse from DeleteZnode response

type EurekaInstance

type EurekaInstance struct {
	Port                  int                    `json:"Port" xml:"Port"`
	SecurePort            int                    `json:"SecurePort" xml:"SecurePort"`
	DurationInSecs        int                    `json:"DurationInSecs" xml:"DurationInSecs"`
	RenewalIntervalInSecs int                    `json:"RenewalIntervalInSecs" xml:"RenewalIntervalInSecs"`
	LastUpdatedTimestamp  int64                  `json:"LastUpdatedTimestamp" xml:"LastUpdatedTimestamp"`
	App                   string                 `json:"App" xml:"App"`
	IpAddr                string                 `json:"IpAddr" xml:"IpAddr"`
	Status                string                 `json:"Status" xml:"Status"`
	HomePageUrl           string                 `json:"HomePageUrl" xml:"HomePageUrl"`
	InstanceId            string                 `json:"InstanceId" xml:"InstanceId"`
	VipAddress            string                 `json:"VipAddress" xml:"VipAddress"`
	HostName              string                 `json:"HostName" xml:"HostName"`
	Metadata              map[string]interface{} `json:"Metadata" xml:"Metadata"`
	LastDirtyTimestamp    int64                  `json:"LastDirtyTimestamp" xml:"LastDirtyTimestamp"`
}

EurekaInstance is a nested struct in mse response

type ExportNacosConfigRequest added in v1.61.998

type ExportNacosConfigRequest struct {
	*requests.RpcRequest
	InstanceId  string `position:"Query" name:"InstanceId"`
	DataId      string `position:"Query" name:"DataId"`
	AppName     string `position:"Query" name:"AppName"`
	NamespaceId string `position:"Query" name:"NamespaceId"`
	Ids         string `position:"Query" name:"Ids"`
	Group       string `position:"Query" name:"Group"`
}

ExportNacosConfigRequest is the request struct for api ExportNacosConfig

func CreateExportNacosConfigRequest added in v1.61.998

func CreateExportNacosConfigRequest() (request *ExportNacosConfigRequest)

CreateExportNacosConfigRequest creates a request to invoke ExportNacosConfig API

type ExportNacosConfigResponse added in v1.61.998

type ExportNacosConfigResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Message        string `json:"Message" xml:"Message"`
	ErrorCode      string `json:"ErrorCode" xml:"ErrorCode"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code           int    `json:"Code" xml:"Code"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	Data           Data   `json:"Data" xml:"Data"`
}

ExportNacosConfigResponse is the response struct for api ExportNacosConfig

func CreateExportNacosConfigResponse added in v1.61.998

func CreateExportNacosConfigResponse() (response *ExportNacosConfigResponse)

CreateExportNacosConfigResponse creates a response to parse from ExportNacosConfig response

type FailDataInCloneNacosConfig added in v1.61.998

type FailDataInCloneNacosConfig struct {
	FailDataItem []FailDataItem `json:"FailData" xml:"FailData"`
}

FailDataInCloneNacosConfig is a nested struct in mse response

type FailDataInImportNacosConfig added in v1.61.998

type FailDataInImportNacosConfig struct {
	FailDataItem []FailDataItem `json:"FailData" xml:"FailData"`
}

FailDataInImportNacosConfig is a nested struct in mse response

type FailDataItem added in v1.61.998

type FailDataItem struct {
	DataId string `json:"DataId" xml:"DataId"`
	Group  string `json:"Group" xml:"Group"`
}

FailDataItem is a nested struct in mse response

type GetEngineNamepaceRequest

type GetEngineNamepaceRequest struct {
	*requests.RpcRequest
	ClusterId  string `position:"Query" name:"ClusterId"`
	InstanceId string `position:"Query" name:"InstanceId"`
	Id         string `position:"Query" name:"Id"`
}

GetEngineNamepaceRequest is the request struct for api GetEngineNamepace

func CreateGetEngineNamepaceRequest

func CreateGetEngineNamepaceRequest() (request *GetEngineNamepaceRequest)

CreateGetEngineNamepaceRequest creates a request to invoke GetEngineNamepace API

type GetEngineNamepaceResponse

type GetEngineNamepaceResponse struct {
	*responses.BaseResponse
	RequestId         string `json:"RequestId" xml:"RequestId"`
	Success           bool   `json:"Success" xml:"Success"`
	Message           string `json:"Message" xml:"Message"`
	ErrorCode         string `json:"ErrorCode" xml:"ErrorCode"`
	HttpCode          string `json:"HttpCode" xml:"HttpCode"`
	Namespace         string `json:"Namespace" xml:"Namespace"`
	NamespaceShowName string `json:"NamespaceShowName" xml:"NamespaceShowName"`
	NamespaceDesc     string `json:"NamespaceDesc" xml:"NamespaceDesc"`
	Quota             string `json:"Quota" xml:"Quota"`
	ConfigCount       string `json:"ConfigCount" xml:"ConfigCount"`
	Type              string `json:"Type" xml:"Type"`
}

GetEngineNamepaceResponse is the response struct for api GetEngineNamepace

func CreateGetEngineNamepaceResponse

func CreateGetEngineNamepaceResponse() (response *GetEngineNamepaceResponse)

CreateGetEngineNamepaceResponse creates a response to parse from GetEngineNamepace response

type GetImportFileUrlRequest added in v1.61.998

type GetImportFileUrlRequest struct {
	*requests.RpcRequest
	ContentType string `position:"Query" name:"ContentType"`
	InstanceId  string `position:"Query" name:"InstanceId"`
	NamespaceId string `position:"Query" name:"NamespaceId"`
}

GetImportFileUrlRequest is the request struct for api GetImportFileUrl

func CreateGetImportFileUrlRequest added in v1.61.998

func CreateGetImportFileUrlRequest() (request *GetImportFileUrlRequest)

CreateGetImportFileUrlRequest creates a request to invoke GetImportFileUrl API

type GetImportFileUrlResponse added in v1.61.998

type GetImportFileUrlResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Message        string `json:"Message" xml:"Message"`
	ErrorCode      string `json:"ErrorCode" xml:"ErrorCode"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code           int    `json:"Code" xml:"Code"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	Data           Data   `json:"Data" xml:"Data"`
}

GetImportFileUrlResponse is the response struct for api GetImportFileUrl

func CreateGetImportFileUrlResponse added in v1.61.998

func CreateGetImportFileUrlResponse() (response *GetImportFileUrlResponse)

CreateGetImportFileUrlResponse creates a response to parse from GetImportFileUrl response

type GetNacosConfigRequest

type GetNacosConfigRequest struct {
	*requests.RpcRequest
	InstanceId  string `position:"Query" name:"InstanceId"`
	DataId      string `position:"Query" name:"DataId"`
	NamespaceId string `position:"Query" name:"NamespaceId"`
	Group       string `position:"Query" name:"Group"`
}

GetNacosConfigRequest is the request struct for api GetNacosConfig

func CreateGetNacosConfigRequest

func CreateGetNacosConfigRequest() (request *GetNacosConfigRequest)

CreateGetNacosConfigRequest creates a request to invoke GetNacosConfig API

type GetNacosConfigResponse

type GetNacosConfigResponse struct {
	*responses.BaseResponse
	RequestId     string        `json:"RequestId" xml:"RequestId"`
	Success       bool          `json:"Success" xml:"Success"`
	Message       string        `json:"Message" xml:"Message"`
	ErrorCode     string        `json:"ErrorCode" xml:"ErrorCode"`
	Configuration Configuration `json:"Configuration" xml:"Configuration"`
}

GetNacosConfigResponse is the response struct for api GetNacosConfig

func CreateGetNacosConfigResponse

func CreateGetNacosConfigResponse() (response *GetNacosConfigResponse)

CreateGetNacosConfigResponse creates a response to parse from GetNacosConfig response

type GetNacosHistoryConfigRequest

type GetNacosHistoryConfigRequest struct {
	*requests.RpcRequest
	Nid         string `position:"Query" name:"Nid"`
	InstanceId  string `position:"Query" name:"InstanceId"`
	DataId      string `position:"Query" name:"DataId"`
	NamespaceId string `position:"Query" name:"NamespaceId"`
	Group       string `position:"Query" name:"Group"`
}

GetNacosHistoryConfigRequest is the request struct for api GetNacosHistoryConfig

func CreateGetNacosHistoryConfigRequest

func CreateGetNacosHistoryConfigRequest() (request *GetNacosHistoryConfigRequest)

CreateGetNacosHistoryConfigRequest creates a request to invoke GetNacosHistoryConfig API

type GetNacosHistoryConfigResponse

type GetNacosHistoryConfigResponse struct {
	*responses.BaseResponse
	RequestId     string        `json:"RequestId" xml:"RequestId"`
	Success       bool          `json:"Success" xml:"Success"`
	Message       string        `json:"Message" xml:"Message"`
	ErrorCode     string        `json:"ErrorCode" xml:"ErrorCode"`
	Configuration Configuration `json:"Configuration" xml:"Configuration"`
}

GetNacosHistoryConfigResponse is the response struct for api GetNacosHistoryConfig

func CreateGetNacosHistoryConfigResponse

func CreateGetNacosHistoryConfigResponse() (response *GetNacosHistoryConfigResponse)

CreateGetNacosHistoryConfigResponse creates a response to parse from GetNacosHistoryConfig response

type GetOverviewRequest added in v1.61.998

type GetOverviewRequest struct {
	*requests.RpcRequest
	Period requests.Integer `position:"Query" name:"Period"`
	Region string           `position:"Query" name:"Region"`
}

GetOverviewRequest is the request struct for api GetOverview

func CreateGetOverviewRequest added in v1.61.998

func CreateGetOverviewRequest() (request *GetOverviewRequest)

CreateGetOverviewRequest creates a request to invoke GetOverview API

type GetOverviewResponse added in v1.61.998

type GetOverviewResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Data           string `json:"Data" xml:"Data"`
	Code           int    `json:"Code" xml:"Code"`
	Success        string `json:"Success" xml:"Success"`
}

GetOverviewResponse is the response struct for api GetOverview

func CreateGetOverviewResponse added in v1.61.998

func CreateGetOverviewResponse() (response *GetOverviewResponse)

CreateGetOverviewResponse creates a response to parse from GetOverview response

type HistoryItem

type HistoryItem struct {
	DataId           string `json:"DataId" xml:"DataId"`
	Group            string `json:"Group" xml:"Group"`
	LastModifiedTime int64  `json:"LastModifiedTime" xml:"LastModifiedTime"`
	Id               int64  `json:"Id" xml:"Id"`
	OpType           string `json:"OpType" xml:"OpType"`
	AppName          string `json:"AppName" xml:"AppName"`
}

HistoryItem is a nested struct in mse response

type HistoryItems

type HistoryItems struct {
	HistoryItem []HistoryItem `json:"HistoryItem" xml:"HistoryItem"`
}

HistoryItems is a nested struct in mse response

type ImportNacosConfigRequest added in v1.61.998

type ImportNacosConfigRequest struct {
	*requests.RpcRequest
	InstanceId  string `position:"Query" name:"InstanceId"`
	NamespaceId string `position:"Query" name:"NamespaceId"`
	FileUrl     string `position:"Query" name:"FileUrl"`
	Policy      string `position:"Query" name:"Policy"`
}

ImportNacosConfigRequest is the request struct for api ImportNacosConfig

func CreateImportNacosConfigRequest added in v1.61.998

func CreateImportNacosConfigRequest() (request *ImportNacosConfigRequest)

CreateImportNacosConfigRequest creates a request to invoke ImportNacosConfig API

type ImportNacosConfigResponse added in v1.61.998

type ImportNacosConfigResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Message        string `json:"Message" xml:"Message"`
	ErrorCode      string `json:"ErrorCode" xml:"ErrorCode"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code           int    `json:"Code" xml:"Code"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	Data           Data   `json:"Data" xml:"Data"`
}

ImportNacosConfigResponse is the response struct for api ImportNacosConfig

func CreateImportNacosConfigResponse added in v1.61.998

func CreateImportNacosConfigResponse() (response *ImportNacosConfigResponse)

CreateImportNacosConfigResponse creates a response to parse from ImportNacosConfig response

type InstanceModel

type InstanceModel struct {
	Role            string `json:"Role" xml:"Role"`
	PodName         string `json:"PodName" xml:"PodName"`
	InternetIp      string `json:"InternetIp" xml:"InternetIp"`
	SingleTunnelVip string `json:"SingleTunnelVip" xml:"SingleTunnelVip"`
	Ip              string `json:"Ip" xml:"Ip"`
	HealthStatus    string `json:"HealthStatus" xml:"HealthStatus"`
}

InstanceModel is a nested struct in mse response

type InstanceModels

type InstanceModels struct {
	InstanceModel []InstanceModel `json:"InstanceModel" xml:"InstanceModel"`
}

InstanceModels is a nested struct in mse response

type InstancesId

type InstancesId struct {
	String []string `json:"String" xml:"String"`
}

InstancesId is a nested struct in mse response

type ListAlarmContactGroupsRequest

type ListAlarmContactGroupsRequest struct {
	*requests.RpcRequest
	PageNum     requests.Integer `position:"Query" name:"PageNum"`
	RequestPars string           `position:"Query" name:"RequestPars"`
	PageSize    requests.Integer `position:"Query" name:"PageSize"`
}

ListAlarmContactGroupsRequest is the request struct for api ListAlarmContactGroups

func CreateListAlarmContactGroupsRequest

func CreateListAlarmContactGroupsRequest() (request *ListAlarmContactGroupsRequest)

CreateListAlarmContactGroupsRequest creates a request to invoke ListAlarmContactGroups API

type ListAlarmContactGroupsResponse

type ListAlarmContactGroupsResponse struct {
	*responses.BaseResponse
	RequestId  string                   `json:"RequestId" xml:"RequestId"`
	Success    bool                     `json:"Success" xml:"Success"`
	Message    string                   `json:"Message" xml:"Message"`
	ErrorCode  string                   `json:"ErrorCode" xml:"ErrorCode"`
	PageNumber int                      `json:"PageNumber" xml:"PageNumber"`
	PageSize   int                      `json:"PageSize" xml:"PageSize"`
	TotalCount int                      `json:"TotalCount" xml:"TotalCount"`
	HttpCode   string                   `json:"HttpCode" xml:"HttpCode"`
	Data       []AlarmContactGroupModel `json:"Data" xml:"Data"`
}

ListAlarmContactGroupsResponse is the response struct for api ListAlarmContactGroups

func CreateListAlarmContactGroupsResponse

func CreateListAlarmContactGroupsResponse() (response *ListAlarmContactGroupsResponse)

CreateListAlarmContactGroupsResponse creates a response to parse from ListAlarmContactGroups response

type ListAlarmHistoriesRequest

type ListAlarmHistoriesRequest struct {
	*requests.RpcRequest
	EndTime      requests.Integer `position:"Query" name:"EndTime"`
	AlarmMseType string           `position:"Query" name:"AlarmMseType"`
	StartTime    requests.Integer `position:"Query" name:"StartTime"`
	PageNum      requests.Integer `position:"Query" name:"PageNum"`
	RequestPars  string           `position:"Query" name:"RequestPars"`
	PageSize     requests.Integer `position:"Query" name:"PageSize"`
	AlarmName    string           `position:"Query" name:"AlarmName"`
}

ListAlarmHistoriesRequest is the request struct for api ListAlarmHistories

func CreateListAlarmHistoriesRequest

func CreateListAlarmHistoriesRequest() (request *ListAlarmHistoriesRequest)

CreateListAlarmHistoriesRequest creates a request to invoke ListAlarmHistories API

type ListAlarmHistoriesResponse

type ListAlarmHistoriesResponse struct {
	*responses.BaseResponse
	RequestId  string              `json:"RequestId" xml:"RequestId"`
	Success    bool                `json:"Success" xml:"Success"`
	Message    string              `json:"Message" xml:"Message"`
	ErrorCode  string              `json:"ErrorCode" xml:"ErrorCode"`
	PageNumber int                 `json:"PageNumber" xml:"PageNumber"`
	PageSize   int                 `json:"PageSize" xml:"PageSize"`
	TotalCount int                 `json:"TotalCount" xml:"TotalCount"`
	HttpCode   string              `json:"HttpCode" xml:"HttpCode"`
	Data       []AlarmHistoryModel `json:"Data" xml:"Data"`
}

ListAlarmHistoriesResponse is the response struct for api ListAlarmHistories

func CreateListAlarmHistoriesResponse

func CreateListAlarmHistoriesResponse() (response *ListAlarmHistoriesResponse)

CreateListAlarmHistoriesResponse creates a response to parse from ListAlarmHistories response

type ListAlarmItemsRequest

type ListAlarmItemsRequest struct {
	*requests.RpcRequest
	RequestPars string `position:"Query" name:"RequestPars"`
}

ListAlarmItemsRequest is the request struct for api ListAlarmItems

func CreateListAlarmItemsRequest

func CreateListAlarmItemsRequest() (request *ListAlarmItemsRequest)

CreateListAlarmItemsRequest creates a request to invoke ListAlarmItems API

type ListAlarmItemsResponse

type ListAlarmItemsResponse struct {
	*responses.BaseResponse
	RequestId  string      `json:"RequestId" xml:"RequestId"`
	Success    bool        `json:"Success" xml:"Success"`
	Message    string      `json:"Message" xml:"Message"`
	ErrorCode  string      `json:"ErrorCode" xml:"ErrorCode"`
	PageNumber int         `json:"PageNumber" xml:"PageNumber"`
	PageSize   int         `json:"PageSize" xml:"PageSize"`
	TotalCount int         `json:"TotalCount" xml:"TotalCount"`
	HttpCode   string      `json:"HttpCode" xml:"HttpCode"`
	Data       []AlarmItem `json:"Data" xml:"Data"`
}

ListAlarmItemsResponse is the response struct for api ListAlarmItems

func CreateListAlarmItemsResponse

func CreateListAlarmItemsResponse() (response *ListAlarmItemsResponse)

CreateListAlarmItemsResponse creates a response to parse from ListAlarmItems response

type ListAlarmRulesRequest

type ListAlarmRulesRequest struct {
	*requests.RpcRequest
	AlarmMseType string           `position:"Query" name:"AlarmMseType"`
	PageNum      requests.Integer `position:"Query" name:"PageNum"`
	RequestPars  string           `position:"Query" name:"RequestPars"`
	PageSize     requests.Integer `position:"Query" name:"PageSize"`
}

ListAlarmRulesRequest is the request struct for api ListAlarmRules

func CreateListAlarmRulesRequest

func CreateListAlarmRulesRequest() (request *ListAlarmRulesRequest)

CreateListAlarmRulesRequest creates a request to invoke ListAlarmRules API

type ListAlarmRulesResponse

type ListAlarmRulesResponse struct {
	*responses.BaseResponse
	RequestId  string           `json:"RequestId" xml:"RequestId"`
	Success    bool             `json:"Success" xml:"Success"`
	Message    string           `json:"Message" xml:"Message"`
	ErrorCode  string           `json:"ErrorCode" xml:"ErrorCode"`
	PageNumber int              `json:"PageNumber" xml:"PageNumber"`
	PageSize   int              `json:"PageSize" xml:"PageSize"`
	TotalCount int              `json:"TotalCount" xml:"TotalCount"`
	HttpCode   string           `json:"HttpCode" xml:"HttpCode"`
	Data       []AlarmRuleModel `json:"Data" xml:"Data"`
}

ListAlarmRulesResponse is the response struct for api ListAlarmRules

func CreateListAlarmRulesResponse

func CreateListAlarmRulesResponse() (response *ListAlarmRulesResponse)

CreateListAlarmRulesResponse creates a response to parse from ListAlarmRules response

type ListAnsInstancesRequest

type ListAnsInstancesRequest struct {
	*requests.RpcRequest
	ClusterName string           `position:"Query" name:"ClusterName"`
	ClusterId   string           `position:"Query" name:"ClusterId"`
	PageNum     requests.Integer `position:"Query" name:"PageNum"`
	GroupName   string           `position:"Query" name:"GroupName"`
	NamespaceId string           `position:"Query" name:"NamespaceId"`
	RequestPars string           `position:"Query" name:"RequestPars"`
	PageSize    requests.Integer `position:"Query" name:"PageSize"`
	ServiceName string           `position:"Query" name:"ServiceName"`
}

ListAnsInstancesRequest is the request struct for api ListAnsInstances

func CreateListAnsInstancesRequest

func CreateListAnsInstancesRequest() (request *ListAnsInstancesRequest)

CreateListAnsInstancesRequest creates a request to invoke ListAnsInstances API

type ListAnsInstancesResponse

type ListAnsInstancesResponse struct {
	*responses.BaseResponse
	RequestId  string             `json:"RequestId" xml:"RequestId"`
	Success    bool               `json:"Success" xml:"Success"`
	Message    string             `json:"Message" xml:"Message"`
	ErrorCode  string             `json:"ErrorCode" xml:"ErrorCode"`
	PageNumber int                `json:"PageNumber" xml:"PageNumber"`
	PageSize   int                `json:"PageSize" xml:"PageSize"`
	TotalCount int                `json:"TotalCount" xml:"TotalCount"`
	HttpCode   string             `json:"HttpCode" xml:"HttpCode"`
	Data       []NacosAnsInstance `json:"Data" xml:"Data"`
}

ListAnsInstancesResponse is the response struct for api ListAnsInstances

func CreateListAnsInstancesResponse

func CreateListAnsInstancesResponse() (response *ListAnsInstancesResponse)

CreateListAnsInstancesResponse creates a response to parse from ListAnsInstances response

type ListAnsServiceClustersRequest

type ListAnsServiceClustersRequest struct {
	*requests.RpcRequest
	ClusterName string           `position:"Query" name:"ClusterName"`
	ClusterId   string           `position:"Query" name:"ClusterId"`
	PageNum     requests.Integer `position:"Query" name:"PageNum"`
	GroupName   string           `position:"Query" name:"GroupName"`
	NamespaceId string           `position:"Query" name:"NamespaceId"`
	RequestPars string           `position:"Query" name:"RequestPars"`
	PageSize    requests.Integer `position:"Query" name:"PageSize"`
	ServiceName string           `position:"Query" name:"ServiceName"`
}

ListAnsServiceClustersRequest is the request struct for api ListAnsServiceClusters

func CreateListAnsServiceClustersRequest

func CreateListAnsServiceClustersRequest() (request *ListAnsServiceClustersRequest)

CreateListAnsServiceClustersRequest creates a request to invoke ListAnsServiceClusters API

type ListAnsServiceClustersResponse

type ListAnsServiceClustersResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	Data      Data   `json:"Data" xml:"Data"`
}

ListAnsServiceClustersResponse is the response struct for api ListAnsServiceClusters

func CreateListAnsServiceClustersResponse

func CreateListAnsServiceClustersResponse() (response *ListAnsServiceClustersResponse)

CreateListAnsServiceClustersResponse creates a response to parse from ListAnsServiceClusters response

type ListAnsServicesRequest

type ListAnsServicesRequest struct {
	*requests.RpcRequest
	ClusterId   string           `position:"Query" name:"ClusterId"`
	PageNum     requests.Integer `position:"Query" name:"PageNum"`
	GroupName   string           `position:"Query" name:"GroupName"`
	HasIpCount  string           `position:"Query" name:"HasIpCount"`
	InstanceId  string           `position:"Query" name:"InstanceId"`
	NamespaceId string           `position:"Query" name:"NamespaceId"`
	RequestPars string           `position:"Query" name:"RequestPars"`
	PageSize    requests.Integer `position:"Query" name:"PageSize"`
	ServiceName string           `position:"Query" name:"ServiceName"`
}

ListAnsServicesRequest is the request struct for api ListAnsServices

func CreateListAnsServicesRequest

func CreateListAnsServicesRequest() (request *ListAnsServicesRequest)

CreateListAnsServicesRequest creates a request to invoke ListAnsServices API

type ListAnsServicesResponse

type ListAnsServicesResponse struct {
	*responses.BaseResponse
	RequestId  string                  `json:"RequestId" xml:"RequestId"`
	Success    bool                    `json:"Success" xml:"Success"`
	Message    string                  `json:"Message" xml:"Message"`
	ErrorCode  string                  `json:"ErrorCode" xml:"ErrorCode"`
	PageNumber int                     `json:"PageNumber" xml:"PageNumber"`
	PageSize   int                     `json:"PageSize" xml:"PageSize"`
	TotalCount int                     `json:"TotalCount" xml:"TotalCount"`
	HttpCode   string                  `json:"HttpCode" xml:"HttpCode"`
	Data       []SimpleNacosAnsService `json:"Data" xml:"Data"`
}

ListAnsServicesResponse is the response struct for api ListAnsServices

func CreateListAnsServicesResponse

func CreateListAnsServicesResponse() (response *ListAnsServicesResponse)

CreateListAnsServicesResponse creates a response to parse from ListAnsServices response

type ListClusterConnectionTypesRequest added in v1.61.998

type ListClusterConnectionTypesRequest struct {
	*requests.RpcRequest
}

ListClusterConnectionTypesRequest is the request struct for api ListClusterConnectionTypes

func CreateListClusterConnectionTypesRequest added in v1.61.998

func CreateListClusterConnectionTypesRequest() (request *ListClusterConnectionTypesRequest)

CreateListClusterConnectionTypesRequest creates a request to invoke ListClusterConnectionTypes API

type ListClusterConnectionTypesResponse added in v1.61.998

type ListClusterConnectionTypesResponse struct {
	*responses.BaseResponse
	RequestId      string     `json:"RequestId" xml:"RequestId"`
	Success        bool       `json:"Success" xml:"Success"`
	Message        string     `json:"Message" xml:"Message"`
	ErrorCode      string     `json:"ErrorCode" xml:"ErrorCode"`
	HttpStatusCode int        `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code           int        `json:"Code" xml:"Code"`
	DynamicMessage string     `json:"DynamicMessage" xml:"DynamicMessage"`
	Data           []DataItem `json:"Data" xml:"Data"`
}

ListClusterConnectionTypesResponse is the response struct for api ListClusterConnectionTypes

func CreateListClusterConnectionTypesResponse added in v1.61.998

func CreateListClusterConnectionTypesResponse() (response *ListClusterConnectionTypesResponse)

CreateListClusterConnectionTypesResponse creates a response to parse from ListClusterConnectionTypes response

type ListClusterTypesRequest added in v1.61.998

type ListClusterTypesRequest struct {
	*requests.RpcRequest
}

ListClusterTypesRequest is the request struct for api ListClusterTypes

func CreateListClusterTypesRequest added in v1.61.998

func CreateListClusterTypesRequest() (request *ListClusterTypesRequest)

CreateListClusterTypesRequest creates a request to invoke ListClusterTypes API

type ListClusterTypesResponse added in v1.61.998

type ListClusterTypesResponse struct {
	*responses.BaseResponse
	RequestId      string     `json:"RequestId" xml:"RequestId"`
	Success        bool       `json:"Success" xml:"Success"`
	Message        string     `json:"Message" xml:"Message"`
	ErrorCode      string     `json:"ErrorCode" xml:"ErrorCode"`
	HttpStatusCode int        `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code           int        `json:"Code" xml:"Code"`
	DynamicMessage string     `json:"DynamicMessage" xml:"DynamicMessage"`
	Data           []DataItem `json:"Data" xml:"Data"`
}

ListClusterTypesResponse is the response struct for api ListClusterTypes

func CreateListClusterTypesResponse added in v1.61.998

func CreateListClusterTypesResponse() (response *ListClusterTypesResponse)

CreateListClusterTypesResponse creates a response to parse from ListClusterTypes response

type ListClusterVersionsRequest added in v1.61.998

type ListClusterVersionsRequest struct {
	*requests.RpcRequest
	ClusterType string `position:"Query" name:"ClusterType"`
}

ListClusterVersionsRequest is the request struct for api ListClusterVersions

func CreateListClusterVersionsRequest added in v1.61.998

func CreateListClusterVersionsRequest() (request *ListClusterVersionsRequest)

CreateListClusterVersionsRequest creates a request to invoke ListClusterVersions API

type ListClusterVersionsResponse added in v1.61.998

type ListClusterVersionsResponse struct {
	*responses.BaseResponse
	RequestId      string     `json:"RequestId" xml:"RequestId"`
	Success        bool       `json:"Success" xml:"Success"`
	Message        string     `json:"Message" xml:"Message"`
	ErrorCode      string     `json:"ErrorCode" xml:"ErrorCode"`
	HttpStatusCode int        `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code           int        `json:"Code" xml:"Code"`
	DynamicMessage string     `json:"DynamicMessage" xml:"DynamicMessage"`
	Data           []DataItem `json:"Data" xml:"Data"`
}

ListClusterVersionsResponse is the response struct for api ListClusterVersions

func CreateListClusterVersionsResponse added in v1.61.998

func CreateListClusterVersionsResponse() (response *ListClusterVersionsResponse)

CreateListClusterVersionsResponse creates a response to parse from ListClusterVersions response

type ListClustersRequest

type ListClustersRequest struct {
	*requests.RpcRequest
	ClusterAliasName string           `position:"Query" name:"ClusterAliasName"`
	PageNum          requests.Integer `position:"Query" name:"PageNum"`
	RequestPars      string           `position:"Query" name:"RequestPars"`
	PageSize         requests.Integer `position:"Query" name:"PageSize"`
}

ListClustersRequest is the request struct for api ListClusters

func CreateListClustersRequest

func CreateListClustersRequest() (request *ListClustersRequest)

CreateListClustersRequest creates a request to invoke ListClusters API

type ListClustersResponse

type ListClustersResponse struct {
	*responses.BaseResponse
	HttpCode   string                `json:"HttpCode" xml:"HttpCode"`
	TotalCount int                   `json:"TotalCount" xml:"TotalCount"`
	PageSize   int                   `json:"PageSize" xml:"PageSize"`
	Message    string                `json:"Message" xml:"Message"`
	RequestId  string                `json:"RequestId" xml:"RequestId"`
	PageNumber int                   `json:"PageNumber" xml:"PageNumber"`
	ErrorCode  string                `json:"ErrorCode" xml:"ErrorCode"`
	Success    bool                  `json:"Success" xml:"Success"`
	Data       []ClusterForListModel `json:"Data" xml:"Data"`
}

ListClustersResponse is the response struct for api ListClusters

func CreateListClustersResponse

func CreateListClustersResponse() (response *ListClustersResponse)

CreateListClustersResponse creates a response to parse from ListClusters response

type ListEngineNamespacesRequest

type ListEngineNamespacesRequest struct {
	*requests.RpcRequest
	ClusterId  string           `position:"Query" name:"ClusterId"`
	PageNum    requests.Integer `position:"Query" name:"PageNum"`
	InstanceId string           `position:"Query" name:"InstanceId"`
	PageSize   requests.Integer `position:"Query" name:"PageSize"`
}

ListEngineNamespacesRequest is the request struct for api ListEngineNamespaces

func CreateListEngineNamespacesRequest

func CreateListEngineNamespacesRequest() (request *ListEngineNamespacesRequest)

CreateListEngineNamespacesRequest creates a request to invoke ListEngineNamespaces API

type ListEngineNamespacesResponse

type ListEngineNamespacesResponse struct {
	*responses.BaseResponse
	RequestId  string      `json:"RequestId" xml:"RequestId"`
	Success    bool        `json:"Success" xml:"Success"`
	Message    string      `json:"Message" xml:"Message"`
	ErrorCode  string      `json:"ErrorCode" xml:"ErrorCode"`
	PageNumber int         `json:"PageNumber" xml:"PageNumber"`
	PageSize   int         `json:"PageSize" xml:"PageSize"`
	TotalCount int         `json:"TotalCount" xml:"TotalCount"`
	HttpCode   string      `json:"HttpCode" xml:"HttpCode"`
	Data       []Namespace `json:"Data" xml:"Data"`
}

ListEngineNamespacesResponse is the response struct for api ListEngineNamespaces

func CreateListEngineNamespacesResponse

func CreateListEngineNamespacesResponse() (response *ListEngineNamespacesResponse)

CreateListEngineNamespacesResponse creates a response to parse from ListEngineNamespaces response

type ListEurekaInstancesRequest

type ListEurekaInstancesRequest struct {
	*requests.RpcRequest
	ClusterId   string           `position:"Query" name:"ClusterId"`
	PageNum     requests.Integer `position:"Query" name:"PageNum"`
	RequestPars string           `position:"Query" name:"RequestPars"`
	PageSize    requests.Integer `position:"Query" name:"PageSize"`
	ServiceName string           `position:"Query" name:"ServiceName"`
}

ListEurekaInstancesRequest is the request struct for api ListEurekaInstances

func CreateListEurekaInstancesRequest

func CreateListEurekaInstancesRequest() (request *ListEurekaInstancesRequest)

CreateListEurekaInstancesRequest creates a request to invoke ListEurekaInstances API

type ListEurekaInstancesResponse

type ListEurekaInstancesResponse struct {
	*responses.BaseResponse
	RequestId  string           `json:"RequestId" xml:"RequestId"`
	Success    bool             `json:"Success" xml:"Success"`
	Message    string           `json:"Message" xml:"Message"`
	ErrorCode  string           `json:"ErrorCode" xml:"ErrorCode"`
	PageNumber int              `json:"PageNumber" xml:"PageNumber"`
	PageSize   int              `json:"PageSize" xml:"PageSize"`
	TotalCount int              `json:"TotalCount" xml:"TotalCount"`
	HttpCode   string           `json:"HttpCode" xml:"HttpCode"`
	Data       []EurekaInstance `json:"Data" xml:"Data"`
}

ListEurekaInstancesResponse is the response struct for api ListEurekaInstances

func CreateListEurekaInstancesResponse

func CreateListEurekaInstancesResponse() (response *ListEurekaInstancesResponse)

CreateListEurekaInstancesResponse creates a response to parse from ListEurekaInstances response

type ListEurekaServicesRequest

type ListEurekaServicesRequest struct {
	*requests.RpcRequest
	ClusterId   string           `position:"Query" name:"ClusterId"`
	PageNum     requests.Integer `position:"Query" name:"PageNum"`
	RequestPars string           `position:"Query" name:"RequestPars"`
	PageSize    requests.Integer `position:"Query" name:"PageSize"`
}

ListEurekaServicesRequest is the request struct for api ListEurekaServices

func CreateListEurekaServicesRequest

func CreateListEurekaServicesRequest() (request *ListEurekaServicesRequest)

CreateListEurekaServicesRequest creates a request to invoke ListEurekaServices API

type ListEurekaServicesResponse

type ListEurekaServicesResponse struct {
	*responses.BaseResponse
	RequestId  string          `json:"RequestId" xml:"RequestId"`
	Success    bool            `json:"Success" xml:"Success"`
	Message    string          `json:"Message" xml:"Message"`
	ErrorCode  string          `json:"ErrorCode" xml:"ErrorCode"`
	PageNumber int             `json:"PageNumber" xml:"PageNumber"`
	PageSize   int             `json:"PageSize" xml:"PageSize"`
	TotalCount int             `json:"TotalCount" xml:"TotalCount"`
	HttpCode   string          `json:"HttpCode" xml:"HttpCode"`
	Data       []SimpleService `json:"Data" xml:"Data"`
}

ListEurekaServicesResponse is the response struct for api ListEurekaServices

func CreateListEurekaServicesResponse

func CreateListEurekaServicesResponse() (response *ListEurekaServicesResponse)

CreateListEurekaServicesResponse creates a response to parse from ListEurekaServices response

type ListListenersByConfigRequest

type ListListenersByConfigRequest struct {
	*requests.RpcRequest
	InstanceId  string `position:"Query" name:"InstanceId"`
	DataId      string `position:"Query" name:"DataId"`
	NamespaceId string `position:"Query" name:"NamespaceId"`
	RequestPars string `position:"Query" name:"RequestPars"`
	Group       string `position:"Query" name:"Group"`
}

ListListenersByConfigRequest is the request struct for api ListListenersByConfig

func CreateListListenersByConfigRequest

func CreateListListenersByConfigRequest() (request *ListListenersByConfigRequest)

CreateListListenersByConfigRequest creates a request to invoke ListListenersByConfig API

type ListListenersByConfigResponse

type ListListenersByConfigResponse struct {
	*responses.BaseResponse
	RequestId  string     `json:"RequestId" xml:"RequestId"`
	Success    bool       `json:"Success" xml:"Success"`
	Message    string     `json:"Message" xml:"Message"`
	ErrorCode  string     `json:"ErrorCode" xml:"ErrorCode"`
	PageNumber int        `json:"PageNumber" xml:"PageNumber"`
	PageSize   int        `json:"PageSize" xml:"PageSize"`
	TotalCount int        `json:"TotalCount" xml:"TotalCount"`
	HttpCode   string     `json:"HttpCode" xml:"HttpCode"`
	Listeners  []Listener `json:"Listeners" xml:"Listeners"`
}

ListListenersByConfigResponse is the response struct for api ListListenersByConfig

func CreateListListenersByConfigResponse

func CreateListListenersByConfigResponse() (response *ListListenersByConfigResponse)

CreateListListenersByConfigResponse creates a response to parse from ListListenersByConfig response

type ListListenersByIpRequest

type ListListenersByIpRequest struct {
	*requests.RpcRequest
	Ip          string `position:"Query" name:"Ip"`
	InstanceId  string `position:"Query" name:"InstanceId"`
	NamespaceId string `position:"Query" name:"NamespaceId"`
	RequestPars string `position:"Query" name:"RequestPars"`
}

ListListenersByIpRequest is the request struct for api ListListenersByIp

func CreateListListenersByIpRequest

func CreateListListenersByIpRequest() (request *ListListenersByIpRequest)

CreateListListenersByIpRequest creates a request to invoke ListListenersByIp API

type ListListenersByIpResponse

type ListListenersByIpResponse struct {
	*responses.BaseResponse
	RequestId  string     `json:"RequestId" xml:"RequestId"`
	Success    bool       `json:"Success" xml:"Success"`
	Message    string     `json:"Message" xml:"Message"`
	ErrorCode  string     `json:"ErrorCode" xml:"ErrorCode"`
	PageNumber int        `json:"PageNumber" xml:"PageNumber"`
	PageSize   int        `json:"PageSize" xml:"PageSize"`
	TotalCount int        `json:"TotalCount" xml:"TotalCount"`
	HttpCode   string     `json:"HttpCode" xml:"HttpCode"`
	Listeners  []Listener `json:"Listeners" xml:"Listeners"`
}

ListListenersByIpResponse is the response struct for api ListListenersByIp

func CreateListListenersByIpResponse

func CreateListListenersByIpResponse() (response *ListListenersByIpResponse)

CreateListListenersByIpResponse creates a response to parse from ListListenersByIp response

type ListNacosConfigsRequest

type ListNacosConfigsRequest struct {
	*requests.RpcRequest
	PageNum     requests.Integer `position:"Query" name:"PageNum"`
	Tags        string           `position:"Query" name:"Tags"`
	InstanceId  string           `position:"Query" name:"InstanceId"`
	DataId      string           `position:"Query" name:"DataId"`
	AppName     string           `position:"Query" name:"AppName"`
	NamespaceId string           `position:"Query" name:"NamespaceId"`
	RequestPars string           `position:"Query" name:"RequestPars"`
	PageSize    requests.Integer `position:"Query" name:"PageSize"`
	Group       string           `position:"Query" name:"Group"`
}

ListNacosConfigsRequest is the request struct for api ListNacosConfigs

func CreateListNacosConfigsRequest

func CreateListNacosConfigsRequest() (request *ListNacosConfigsRequest)

CreateListNacosConfigsRequest creates a request to invoke ListNacosConfigs API

type ListNacosConfigsResponse

type ListNacosConfigsResponse struct {
	*responses.BaseResponse
	RequestId      string                    `json:"RequestId" xml:"RequestId"`
	Success        bool                      `json:"Success" xml:"Success"`
	Message        string                    `json:"Message" xml:"Message"`
	ErrorCode      string                    `json:"ErrorCode" xml:"ErrorCode"`
	PageNumber     int                       `json:"PageNumber" xml:"PageNumber"`
	PageSize       int                       `json:"PageSize" xml:"PageSize"`
	TotalCount     int                       `json:"TotalCount" xml:"TotalCount"`
	HttpCode       string                    `json:"HttpCode" xml:"HttpCode"`
	Code           int                       `json:"Code" xml:"Code"`
	Configurations []NacosConfigForListModel `json:"Configurations" xml:"Configurations"`
}

ListNacosConfigsResponse is the response struct for api ListNacosConfigs

func CreateListNacosConfigsResponse

func CreateListNacosConfigsResponse() (response *ListNacosConfigsResponse)

CreateListNacosConfigsResponse creates a response to parse from ListNacosConfigs response

type ListNacosHistoryConfigsRequest

type ListNacosHistoryConfigsRequest struct {
	*requests.RpcRequest
	PageNum     requests.Integer `position:"Query" name:"PageNum"`
	InstanceId  string           `position:"Query" name:"InstanceId"`
	DataId      string           `position:"Query" name:"DataId"`
	NamespaceId string           `position:"Query" name:"NamespaceId"`
	RequestPars string           `position:"Query" name:"RequestPars"`
	PageSize    requests.Integer `position:"Query" name:"PageSize"`
	Group       string           `position:"Query" name:"Group"`
}

ListNacosHistoryConfigsRequest is the request struct for api ListNacosHistoryConfigs

func CreateListNacosHistoryConfigsRequest

func CreateListNacosHistoryConfigsRequest() (request *ListNacosHistoryConfigsRequest)

CreateListNacosHistoryConfigsRequest creates a request to invoke ListNacosHistoryConfigs API

type ListNacosHistoryConfigsResponse

type ListNacosHistoryConfigsResponse struct {
	*responses.BaseResponse
	RequestId    string        `json:"RequestId" xml:"RequestId"`
	Success      bool          `json:"Success" xml:"Success"`
	Message      string        `json:"Message" xml:"Message"`
	ErrorCode    string        `json:"ErrorCode" xml:"ErrorCode"`
	PageNumber   int           `json:"PageNumber" xml:"PageNumber"`
	PageSize     int           `json:"PageSize" xml:"PageSize"`
	TotalCount   int           `json:"TotalCount" xml:"TotalCount"`
	HttpCode     string        `json:"HttpCode" xml:"HttpCode"`
	HistoryItems []HistoryItem `json:"HistoryItems" xml:"HistoryItems"`
}

ListNacosHistoryConfigsResponse is the response struct for api ListNacosHistoryConfigs

func CreateListNacosHistoryConfigsResponse

func CreateListNacosHistoryConfigsResponse() (response *ListNacosHistoryConfigsResponse)

CreateListNacosHistoryConfigsResponse creates a response to parse from ListNacosHistoryConfigs response

type ListZnodeChildrenRequest

type ListZnodeChildrenRequest struct {
	*requests.RpcRequest
	ClusterId string `position:"Query" name:"ClusterId"`
	Path      string `position:"Query" name:"Path"`
}

ListZnodeChildrenRequest is the request struct for api ListZnodeChildren

func CreateListZnodeChildrenRequest

func CreateListZnodeChildrenRequest() (request *ListZnodeChildrenRequest)

CreateListZnodeChildrenRequest creates a request to invoke ListZnodeChildren API

type ListZnodeChildrenResponse

type ListZnodeChildrenResponse struct {
	*responses.BaseResponse
	RequestId string       `json:"RequestId" xml:"RequestId"`
	Success   bool         `json:"Success" xml:"Success"`
	Message   string       `json:"Message" xml:"Message"`
	ErrorCode string       `json:"ErrorCode" xml:"ErrorCode"`
	Data      []ZnodeModel `json:"Data" xml:"Data"`
}

ListZnodeChildrenResponse is the response struct for api ListZnodeChildren

func CreateListZnodeChildrenResponse

func CreateListZnodeChildrenResponse() (response *ListZnodeChildrenResponse)

CreateListZnodeChildrenResponse creates a response to parse from ListZnodeChildren response

type Listener

type Listener struct {
	DataId string `json:"DataId" xml:"DataId"`
	Group  string `json:"Group" xml:"Group"`
	Ip     string `json:"Ip" xml:"Ip"`
	Md5    string `json:"Md5" xml:"Md5"`
}

Listener is a nested struct in mse response

type ListenersInListListenersByConfig

type ListenersInListListenersByConfig struct {
	Listener []Listener `json:"Listener" xml:"Listener"`
}

ListenersInListListenersByConfig is a nested struct in mse response

type ListenersInListListenersByIp

type ListenersInListListenersByIp struct {
	Listener []Listener `json:"Listener" xml:"Listener"`
}

ListenersInListListenersByIp is a nested struct in mse response

type LocationData

type LocationData struct {
	Type             string `json:"Type" xml:"Type"`
	Name             string `json:"Name" xml:"Name"`
	CnName           string `json:"CnName" xml:"CnName"`
	EnName           string `json:"EnName" xml:"EnName"`
	ShowName         string `json:"ShowName" xml:"ShowName"`
	Description      string `json:"Description" xml:"Description"`
	EnDescription    string `json:"EnDescription" xml:"EnDescription"`
	Ordering         int    `json:"Ordering" xml:"Ordering"`
	DistrictId       string `json:"DistrictId" xml:"DistrictId"`
	DistrictCnName   string `json:"DistrictCnName" xml:"DistrictCnName"`
	DistrictEnName   string `json:"DistrictEnName" xml:"DistrictEnName"`
	DistrictShowName string `json:"DistrictShowName" xml:"DistrictShowName"`
	DistrictOrdering int    `json:"DistrictOrdering" xml:"DistrictOrdering"`
}

LocationData is a nested struct in mse response

type NacosAnsCluster

type NacosAnsCluster struct {
	ServiceName       string                 `json:"ServiceName" xml:"ServiceName"`
	Name              string                 `json:"Name" xml:"Name"`
	HealthCheckerType string                 `json:"HealthCheckerType" xml:"HealthCheckerType"`
	DefaultPort       int                    `json:"DefaultPort" xml:"DefaultPort"`
	DefaultCheckPort  int                    `json:"DefaultCheckPort" xml:"DefaultCheckPort"`
	UseIPPort4Check   bool                   `json:"UseIPPort4Check" xml:"UseIPPort4Check"`
	Metadata          map[string]interface{} `json:"Metadata" xml:"Metadata"`
}

NacosAnsCluster is a nested struct in mse response

type NacosAnsInstance

type NacosAnsInstance struct {
	Enabled                   bool                   `json:"Enabled" xml:"Enabled"`
	Ephemeral                 bool                   `json:"Ephemeral" xml:"Ephemeral"`
	Healthy                   bool                   `json:"Healthy" xml:"Healthy"`
	Marked                    bool                   `json:"Marked" xml:"Marked"`
	FailCount                 int                    `json:"FailCount" xml:"FailCount"`
	Port                      int                    `json:"Port" xml:"Port"`
	InstanceHeartBeatInterval int                    `json:"InstanceHeartBeatInterval" xml:"InstanceHeartBeatInterval"`
	InstanceHeartBeatTimeOut  int                    `json:"InstanceHeartBeatTimeOut" xml:"InstanceHeartBeatTimeOut"`
	IpDeleteTimeout           int                    `json:"IpDeleteTimeout" xml:"IpDeleteTimeout"`
	OkCount                   int                    `json:"OkCount" xml:"OkCount"`
	Weight                    int                    `json:"Weight" xml:"Weight"`
	LastBeat                  int64                  `json:"LastBeat" xml:"LastBeat"`
	App                       string                 `json:"App" xml:"App"`
	ClusterName               string                 `json:"ClusterName" xml:"ClusterName"`
	DatumKey                  string                 `json:"DatumKey" xml:"DatumKey"`
	DefaultKey                string                 `json:"DefaultKey" xml:"DefaultKey"`
	InstanceId                string                 `json:"InstanceId" xml:"InstanceId"`
	Ip                        string                 `json:"Ip" xml:"Ip"`
	ServiceName               string                 `json:"ServiceName" xml:"ServiceName"`
	Metadata                  map[string]interface{} `json:"Metadata" xml:"Metadata"`
}

NacosAnsInstance is a nested struct in mse response

type NacosConfigForListModel

type NacosConfigForListModel struct {
	DataId  string `json:"DataId" xml:"DataId"`
	Group   string `json:"Group" xml:"Group"`
	AppName string `json:"AppName" xml:"AppName"`
	Id      string `json:"Id" xml:"Id"`
}

NacosConfigForListModel is a nested struct in mse response

type Namespace

type Namespace struct {
	Namespace         string `json:"Namespace" xml:"Namespace"`
	NamespaceShowName string `json:"NamespaceShowName" xml:"NamespaceShowName"`
	NamespaceDesc     string `json:"NamespaceDesc" xml:"NamespaceDesc"`
	Quota             int    `json:"Quota" xml:"Quota"`
	ConfigCount       int    `json:"ConfigCount" xml:"ConfigCount"`
	Type              int    `json:"Type" xml:"Type"`
	ServiceCount      string `json:"ServiceCount" xml:"ServiceCount"`
}

Namespace is a nested struct in mse response

type QueryBusinessLocationsRequest

type QueryBusinessLocationsRequest struct {
	*requests.RpcRequest
}

QueryBusinessLocationsRequest is the request struct for api QueryBusinessLocations

func CreateQueryBusinessLocationsRequest

func CreateQueryBusinessLocationsRequest() (request *QueryBusinessLocationsRequest)

CreateQueryBusinessLocationsRequest creates a request to invoke QueryBusinessLocations API

type QueryBusinessLocationsResponse

type QueryBusinessLocationsResponse struct {
	*responses.BaseResponse
	RequestId string         `json:"RequestId" xml:"RequestId"`
	Success   string         `json:"Success" xml:"Success"`
	Message   string         `json:"Message" xml:"Message"`
	ErrorCode string         `json:"ErrorCode" xml:"ErrorCode"`
	Data      []LocationData `json:"Data" xml:"Data"`
}

QueryBusinessLocationsResponse is the response struct for api QueryBusinessLocations

func CreateQueryBusinessLocationsResponse

func CreateQueryBusinessLocationsResponse() (response *QueryBusinessLocationsResponse)

CreateQueryBusinessLocationsResponse creates a response to parse from QueryBusinessLocations response

type QueryClusterDetailRequest

type QueryClusterDetailRequest struct {
	*requests.RpcRequest
	OrderId    string `position:"Query" name:"OrderId"`
	ClusterId  string `position:"Query" name:"ClusterId"`
	InstanceId string `position:"Query" name:"InstanceId"`
}

QueryClusterDetailRequest is the request struct for api QueryClusterDetail

func CreateQueryClusterDetailRequest

func CreateQueryClusterDetailRequest() (request *QueryClusterDetailRequest)

CreateQueryClusterDetailRequest creates a request to invoke QueryClusterDetail API

type QueryClusterDetailResponse

type QueryClusterDetailResponse struct {
	*responses.BaseResponse
	RequestId string                   `json:"RequestId" xml:"RequestId"`
	Message   string                   `json:"Message" xml:"Message"`
	ErrorCode string                   `json:"ErrorCode" xml:"ErrorCode"`
	Success   bool                     `json:"Success" xml:"Success"`
	Data      DataInQueryClusterDetail `json:"Data" xml:"Data"`
}

QueryClusterDetailResponse is the response struct for api QueryClusterDetail

func CreateQueryClusterDetailResponse

func CreateQueryClusterDetailResponse() (response *QueryClusterDetailResponse)

CreateQueryClusterDetailResponse creates a response to parse from QueryClusterDetail response

type QueryClusterDiskSpecificationRequest added in v1.61.998

type QueryClusterDiskSpecificationRequest struct {
	*requests.RpcRequest
	ClusterType string `position:"Query" name:"ClusterType"`
}

QueryClusterDiskSpecificationRequest is the request struct for api QueryClusterDiskSpecification

func CreateQueryClusterDiskSpecificationRequest added in v1.61.998

func CreateQueryClusterDiskSpecificationRequest() (request *QueryClusterDiskSpecificationRequest)

CreateQueryClusterDiskSpecificationRequest creates a request to invoke QueryClusterDiskSpecification API

type QueryClusterDiskSpecificationResponse added in v1.61.998

type QueryClusterDiskSpecificationResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Message        string `json:"Message" xml:"Message"`
	ErrorCode      string `json:"ErrorCode" xml:"ErrorCode"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code           int    `json:"Code" xml:"Code"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	Data           Data   `json:"Data" xml:"Data"`
}

QueryClusterDiskSpecificationResponse is the response struct for api QueryClusterDiskSpecification

func CreateQueryClusterDiskSpecificationResponse added in v1.61.998

func CreateQueryClusterDiskSpecificationResponse() (response *QueryClusterDiskSpecificationResponse)

CreateQueryClusterDiskSpecificationResponse creates a response to parse from QueryClusterDiskSpecification response

type QueryClusterSpecificationRequest

type QueryClusterSpecificationRequest struct {
	*requests.RpcRequest
}

QueryClusterSpecificationRequest is the request struct for api QueryClusterSpecification

func CreateQueryClusterSpecificationRequest

func CreateQueryClusterSpecificationRequest() (request *QueryClusterSpecificationRequest)

CreateQueryClusterSpecificationRequest creates a request to invoke QueryClusterSpecification API

type QueryClusterSpecificationResponse

type QueryClusterSpecificationResponse struct {
	*responses.BaseResponse
	RequestId      string     `json:"RequestId" xml:"RequestId"`
	Success        bool       `json:"Success" xml:"Success"`
	Message        string     `json:"Message" xml:"Message"`
	ErrorCode      string     `json:"ErrorCode" xml:"ErrorCode"`
	Code           int        `json:"Code" xml:"Code"`
	HttpStatusCode int        `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Data           []DataItem `json:"Data" xml:"Data"`
}

QueryClusterSpecificationResponse is the response struct for api QueryClusterSpecification

func CreateQueryClusterSpecificationResponse

func CreateQueryClusterSpecificationResponse() (response *QueryClusterSpecificationResponse)

CreateQueryClusterSpecificationResponse creates a response to parse from QueryClusterSpecification response

type QueryConfigRequest

type QueryConfigRequest struct {
	*requests.RpcRequest
	ConfigType  string `position:"Query" name:"ConfigType"`
	ClusterId   string `position:"Query" name:"ClusterId"`
	InstanceId  string `position:"Query" name:"InstanceId"`
	RequestPars string `position:"Query" name:"RequestPars"`
}

QueryConfigRequest is the request struct for api QueryConfig

func CreateQueryConfigRequest

func CreateQueryConfigRequest() (request *QueryConfigRequest)

CreateQueryConfigRequest creates a request to invoke QueryConfig API

type QueryConfigResponse

type QueryConfigResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   string `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	Data      Data   `json:"Data" xml:"Data"`
}

QueryConfigResponse is the response struct for api QueryConfig

func CreateQueryConfigResponse

func CreateQueryConfigResponse() (response *QueryConfigResponse)

CreateQueryConfigResponse creates a response to parse from QueryConfig response

type QueryMonitorRequest

type QueryMonitorRequest struct {
	*requests.RpcRequest
	MonitorType string           `position:"Query" name:"MonitorType"`
	EndTime     requests.Integer `position:"Query" name:"EndTime"`
	ClusterId   string           `position:"Query" name:"ClusterId"`
	StartTime   requests.Integer `position:"Query" name:"StartTime"`
	InstanceId  string           `position:"Query" name:"InstanceId"`
	RequestPars string           `position:"Query" name:"RequestPars"`
	Step        requests.Integer `position:"Query" name:"Step"`
}

QueryMonitorRequest is the request struct for api QueryMonitor

func CreateQueryMonitorRequest

func CreateQueryMonitorRequest() (request *QueryMonitorRequest)

CreateQueryMonitorRequest creates a request to invoke QueryMonitor API

type QueryMonitorResponse

type QueryMonitorResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      string `json:"Data" xml:"Data"`
}

QueryMonitorResponse is the response struct for api QueryMonitor

func CreateQueryMonitorResponse

func CreateQueryMonitorResponse() (response *QueryMonitorResponse)

CreateQueryMonitorResponse creates a response to parse from QueryMonitor response

type QueryZnodeDetailRequest

type QueryZnodeDetailRequest struct {
	*requests.RpcRequest
	ClusterId   string `position:"Query" name:"ClusterId"`
	Path        string `position:"Query" name:"Path"`
	RequestPars string `position:"Query" name:"RequestPars"`
}

QueryZnodeDetailRequest is the request struct for api QueryZnodeDetail

func CreateQueryZnodeDetailRequest

func CreateQueryZnodeDetailRequest() (request *QueryZnodeDetailRequest)

CreateQueryZnodeDetailRequest creates a request to invoke QueryZnodeDetail API

type QueryZnodeDetailResponse

type QueryZnodeDetailResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   string `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	Data      Data   `json:"Data" xml:"Data"`
}

QueryZnodeDetailResponse is the response struct for api QueryZnodeDetail

func CreateQueryZnodeDetailResponse

func CreateQueryZnodeDetailResponse() (response *QueryZnodeDetailResponse)

CreateQueryZnodeDetailResponse creates a response to parse from QueryZnodeDetail response

type RestartClusterRequest

type RestartClusterRequest struct {
	*requests.RpcRequest
	ClusterId   string `position:"Query" name:"ClusterId"`
	InstanceId  string `position:"Query" name:"InstanceId"`
	RequestPars string `position:"Query" name:"RequestPars"`
}

RestartClusterRequest is the request struct for api RestartCluster

func CreateRestartClusterRequest

func CreateRestartClusterRequest() (request *RestartClusterRequest)

CreateRestartClusterRequest creates a request to invoke RestartCluster API

type RestartClusterResponse

type RestartClusterResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
}

RestartClusterResponse is the response struct for api RestartCluster

func CreateRestartClusterResponse

func CreateRestartClusterResponse() (response *RestartClusterResponse)

CreateRestartClusterResponse creates a response to parse from RestartCluster response

type RetryClusterRequest

type RetryClusterRequest struct {
	*requests.RpcRequest
	ClusterId   string `position:"Query" name:"ClusterId"`
	InstanceId  string `position:"Query" name:"InstanceId"`
	RequestPars string `position:"Query" name:"RequestPars"`
}

RetryClusterRequest is the request struct for api RetryCluster

func CreateRetryClusterRequest

func CreateRetryClusterRequest() (request *RetryClusterRequest)

CreateRetryClusterRequest creates a request to invoke RetryCluster API

type RetryClusterResponse

type RetryClusterResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
}

RetryClusterResponse is the response struct for api RetryCluster

func CreateRetryClusterResponse

func CreateRetryClusterResponse() (response *RetryClusterResponse)

CreateRetryClusterResponse creates a response to parse from RetryCluster response

type ScalingClusterRequest

type ScalingClusterRequest struct {
	*requests.RpcRequest
	ClusterSpecification string           `position:"Query" name:"ClusterSpecification"`
	Cpu                  requests.Integer `position:"Query" name:"Cpu"`
	ClusterId            string           `position:"Query" name:"ClusterId"`
	InstanceId           string           `position:"Query" name:"InstanceId"`
	MemoryCapacity       requests.Integer `position:"Query" name:"MemoryCapacity"`
	InstanceCount        requests.Integer `position:"Query" name:"InstanceCount"`
}

ScalingClusterRequest is the request struct for api ScalingCluster

func CreateScalingClusterRequest

func CreateScalingClusterRequest() (request *ScalingClusterRequest)

CreateScalingClusterRequest creates a request to invoke ScalingCluster API

type ScalingClusterResponse

type ScalingClusterResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
}

ScalingClusterResponse is the response struct for api ScalingCluster

func CreateScalingClusterResponse

func CreateScalingClusterResponse() (response *ScalingClusterResponse)

CreateScalingClusterResponse creates a response to parse from ScalingCluster response

type SimpleNacosAnsService

type SimpleNacosAnsService struct {
	Name                 string `json:"Name" xml:"Name"`
	GroupName            string `json:"GroupName" xml:"GroupName"`
	ClusterCount         int    `json:"ClusterCount" xml:"ClusterCount"`
	IpCount              int    `json:"IpCount" xml:"IpCount"`
	HealthyInstanceCount int    `json:"HealthyInstanceCount" xml:"HealthyInstanceCount"`
}

SimpleNacosAnsService is a nested struct in mse response

type SimpleService

type SimpleService struct {
	Name        string   `json:"Name" xml:"Name"`
	UpStatus    string   `json:"UpStatus" xml:"UpStatus"`
	InstancesId []string `json:"InstancesId" xml:"InstancesId"`
}

SimpleService is a nested struct in mse response

type SkipDataInCloneNacosConfig added in v1.61.998

type SkipDataInCloneNacosConfig struct {
	SkipDataItem []SkipDataItem `json:"SkipData" xml:"SkipData"`
}

SkipDataInCloneNacosConfig is a nested struct in mse response

type SkipDataInImportNacosConfig added in v1.61.998

type SkipDataInImportNacosConfig struct {
	SkipDataItem []SkipDataItem `json:"SkipData" xml:"SkipData"`
}

SkipDataInImportNacosConfig is a nested struct in mse response

type SkipDataItem added in v1.61.998

type SkipDataItem struct {
	DataId string `json:"DataId" xml:"DataId"`
	Group  string `json:"Group" xml:"Group"`
}

SkipDataItem is a nested struct in mse response

type UpdateAclRequest

type UpdateAclRequest struct {
	*requests.RpcRequest
	ClusterId    string `position:"Query" name:"ClusterId"`
	AclEntryList string `position:"Query" name:"AclEntryList"`
	InstanceId   string `position:"Query" name:"InstanceId"`
}

UpdateAclRequest is the request struct for api UpdateAcl

func CreateUpdateAclRequest

func CreateUpdateAclRequest() (request *UpdateAclRequest)

CreateUpdateAclRequest creates a request to invoke UpdateAcl API

type UpdateAclResponse

type UpdateAclResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateAclResponse is the response struct for api UpdateAcl

func CreateUpdateAclResponse

func CreateUpdateAclResponse() (response *UpdateAclResponse)

CreateUpdateAclResponse creates a response to parse from UpdateAcl response

type UpdateClusterRequest

type UpdateClusterRequest struct {
	*requests.RpcRequest
	ClusterAliasName string `position:"Query" name:"ClusterAliasName"`
	ClusterId        string `position:"Query" name:"ClusterId"`
	InstanceId       string `position:"Query" name:"InstanceId"`
	RequestPars      string `position:"Query" name:"RequestPars"`
}

UpdateClusterRequest is the request struct for api UpdateCluster

func CreateUpdateClusterRequest

func CreateUpdateClusterRequest() (request *UpdateClusterRequest)

CreateUpdateClusterRequest creates a request to invoke UpdateCluster API

type UpdateClusterResponse

type UpdateClusterResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateClusterResponse is the response struct for api UpdateCluster

func CreateUpdateClusterResponse

func CreateUpdateClusterResponse() (response *UpdateClusterResponse)

CreateUpdateClusterResponse creates a response to parse from UpdateCluster response

type UpdateConfigRequest

type UpdateConfigRequest struct {
	*requests.RpcRequest
	OpenSuperAcl             string           `position:"Body" name:"OpenSuperAcl"`
	ConfigAuthEnabled        requests.Boolean `position:"Query" name:"ConfigAuthEnabled"`
	PassWord                 string           `position:"Query" name:"PassWord"`
	MaxClientCnxns           string           `position:"Query" name:"MaxClientCnxns"`
	RequestPars              string           `position:"Query" name:"RequestPars"`
	JuteMaxbuffer            string           `position:"Query" name:"JuteMaxbuffer"`
	ConfigType               string           `position:"Query" name:"ConfigType"`
	AutopurgeSnapRetainCount string           `position:"Query" name:"AutopurgeSnapRetainCount"`
	MCPEnabled               requests.Boolean `position:"Query" name:"MCPEnabled"`
	TickTime                 string           `position:"Query" name:"TickTime"`
	ClusterId                string           `position:"Query" name:"ClusterId"`
	SyncLimit                string           `position:"Query" name:"SyncLimit"`
	InstanceId               string           `position:"Query" name:"InstanceId"`
	AutopurgePurgeInterval   string           `position:"Query" name:"AutopurgePurgeInterval"`
	InitLimit                string           `position:"Query" name:"InitLimit"`
	UserName                 string           `position:"Query" name:"UserName"`
}

UpdateConfigRequest is the request struct for api UpdateConfig

func CreateUpdateConfigRequest

func CreateUpdateConfigRequest() (request *UpdateConfigRequest)

CreateUpdateConfigRequest creates a request to invoke UpdateConfig API

type UpdateConfigResponse

type UpdateConfigResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateConfigResponse is the response struct for api UpdateConfig

func CreateUpdateConfigResponse

func CreateUpdateConfigResponse() (response *UpdateConfigResponse)

CreateUpdateConfigResponse creates a response to parse from UpdateConfig response

type UpdateEngineNamespaceRequest

type UpdateEngineNamespaceRequest struct {
	*requests.RpcRequest
	ClusterId    string           `position:"Query" name:"ClusterId"`
	InstanceId   string           `position:"Query" name:"InstanceId"`
	ServiceCount requests.Integer `position:"Query" name:"ServiceCount"`
	Name         string           `position:"Query" name:"Name"`
	Id           string           `position:"Query" name:"Id"`
	Desc         string           `position:"Query" name:"Desc"`
}

UpdateEngineNamespaceRequest is the request struct for api UpdateEngineNamespace

func CreateUpdateEngineNamespaceRequest

func CreateUpdateEngineNamespaceRequest() (request *UpdateEngineNamespaceRequest)

CreateUpdateEngineNamespaceRequest creates a request to invoke UpdateEngineNamespace API

type UpdateEngineNamespaceResponse

type UpdateEngineNamespaceResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

UpdateEngineNamespaceResponse is the response struct for api UpdateEngineNamespace

func CreateUpdateEngineNamespaceResponse

func CreateUpdateEngineNamespaceResponse() (response *UpdateEngineNamespaceResponse)

CreateUpdateEngineNamespaceResponse creates a response to parse from UpdateEngineNamespace response

type UpdateNacosConfigRequest

type UpdateNacosConfigRequest struct {
	*requests.RpcRequest
	Type        string `position:"Query" name:"Type"`
	Content     string `position:"Query" name:"Content"`
	Tags        string `position:"Query" name:"Tags"`
	BetaIps     string `position:"Query" name:"BetaIps"`
	InstanceId  string `position:"Query" name:"InstanceId"`
	DataId      string `position:"Query" name:"DataId"`
	AppName     string `position:"Query" name:"AppName"`
	NamespaceId string `position:"Query" name:"NamespaceId"`
	Group       string `position:"Query" name:"Group"`
	Desc        string `position:"Query" name:"Desc"`
	Md5         string `position:"Query" name:"Md5"`
}

UpdateNacosConfigRequest is the request struct for api UpdateNacosConfig

func CreateUpdateNacosConfigRequest

func CreateUpdateNacosConfigRequest() (request *UpdateNacosConfigRequest)

CreateUpdateNacosConfigRequest creates a request to invoke UpdateNacosConfig API

type UpdateNacosConfigResponse

type UpdateNacosConfigResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	HttpCode  string `json:"HttpCode" xml:"HttpCode"`
}

UpdateNacosConfigResponse is the response struct for api UpdateNacosConfig

func CreateUpdateNacosConfigResponse

func CreateUpdateNacosConfigResponse() (response *UpdateNacosConfigResponse)

CreateUpdateNacosConfigResponse creates a response to parse from UpdateNacosConfig response

type UpdateNacosInstanceRequest added in v1.61.998

type UpdateNacosInstanceRequest struct {
	*requests.RpcRequest
	Metadata    string           `position:"Body" name:"Metadata"`
	ClusterName string           `position:"Query" name:"ClusterName"`
	Ip          string           `position:"Query" name:"Ip"`
	Ephemeral   requests.Boolean `position:"Query" name:"Ephemeral"`
	Weight      string           `position:"Query" name:"Weight"`
	GroupName   string           `position:"Query" name:"GroupName"`
	Enabled     requests.Boolean `position:"Query" name:"Enabled"`
	InstanceId  string           `position:"Query" name:"InstanceId"`
	NamespaceId string           `position:"Query" name:"NamespaceId"`
	Port        requests.Integer `position:"Query" name:"Port"`
	ServiceName string           `position:"Query" name:"ServiceName"`
}

UpdateNacosInstanceRequest is the request struct for api UpdateNacosInstance

func CreateUpdateNacosInstanceRequest added in v1.61.998

func CreateUpdateNacosInstanceRequest() (request *UpdateNacosInstanceRequest)

CreateUpdateNacosInstanceRequest creates a request to invoke UpdateNacosInstance API

type UpdateNacosInstanceResponse added in v1.61.998

type UpdateNacosInstanceResponse struct {
	*responses.BaseResponse
	Message        string `json:"Message" xml:"Message"`
	RequestId      string `json:"RequestId" xml:"RequestId"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Data           string `json:"Data" xml:"Data"`
	Code           int    `json:"Code" xml:"Code"`
	Success        bool   `json:"Success" xml:"Success"`
}

UpdateNacosInstanceResponse is the response struct for api UpdateNacosInstance

func CreateUpdateNacosInstanceResponse added in v1.61.998

func CreateUpdateNacosInstanceResponse() (response *UpdateNacosInstanceResponse)

CreateUpdateNacosInstanceResponse creates a response to parse from UpdateNacosInstance response

type UpdateZnodeRequest

type UpdateZnodeRequest struct {
	*requests.RpcRequest
	Data        string `position:"Query" name:"Data"`
	ClusterId   string `position:"Query" name:"ClusterId"`
	Path        string `position:"Query" name:"Path"`
	RequestPars string `position:"Query" name:"RequestPars"`
}

UpdateZnodeRequest is the request struct for api UpdateZnode

func CreateUpdateZnodeRequest

func CreateUpdateZnodeRequest() (request *UpdateZnodeRequest)

CreateUpdateZnodeRequest creates a request to invoke UpdateZnode API

type UpdateZnodeResponse

type UpdateZnodeResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateZnodeResponse is the response struct for api UpdateZnode

func CreateUpdateZnodeResponse

func CreateUpdateZnodeResponse() (response *UpdateZnodeResponse)

CreateUpdateZnodeResponse creates a response to parse from UpdateZnode response

type UpgradeClusterRequest

type UpgradeClusterRequest struct {
	*requests.RpcRequest
	UpgradeVersion string `position:"Query" name:"UpgradeVersion"`
	InstanceId     string `position:"Query" name:"InstanceId"`
	RequestPars    string `position:"Query" name:"RequestPars"`
}

UpgradeClusterRequest is the request struct for api UpgradeCluster

func CreateUpgradeClusterRequest

func CreateUpgradeClusterRequest() (request *UpgradeClusterRequest)

CreateUpgradeClusterRequest creates a request to invoke UpgradeCluster API

type UpgradeClusterResponse

type UpgradeClusterResponse struct {
	*responses.BaseResponse
	Success   bool   `json:"Success" xml:"Success"`
	Message   string `json:"Message" xml:"Message"`
	ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	HttpCode  string `json:"HttpCode" xml:"HttpCode"`
}

UpgradeClusterResponse is the response struct for api UpgradeCluster

func CreateUpgradeClusterResponse

func CreateUpgradeClusterResponse() (response *UpgradeClusterResponse)

CreateUpgradeClusterResponse creates a response to parse from UpgradeCluster response

type ZnodeModel

type ZnodeModel struct {
	Path string `json:"Path" xml:"Path"`
	Name string `json:"Name" xml:"Name"`
	Data string `json:"Data" xml:"Data"`
	Dir  bool   `json:"Dir" xml:"Dir"`
}

ZnodeModel is a nested struct in mse response

Source Files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL