resolve type bugs

Signed-off-by: 高汝彤 <rutong.grt@alibaba-inc.com>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

sdk/requests/types.go

@@ -0,0 +1,45 @@
+package requests
+
+import "strconv"
+
+type Integer string
+
+func NewInteger(n int) Integer {
+	return Integer(strconv.Itoa(n))
+}
+
+func (integer Integer) hasValue() bool {
+	return  integer != ""
+}
+
+func (integer Integer) getValue() (int, error){
+	return strconv.Atoi(string(integer))
+}
+
+type Boolean string
+
+func NewBoolean(bool bool) Boolean {
+	return Boolean(strconv.FormatBool(bool))
+}
+
+func (boolean Boolean) hasValue() bool {
+	return  boolean != ""
+}
+
+func (boolean Boolean) getValue() (bool, error){
+	return strconv.ParseBool(string(boolean))
+}
+
+type Float string
+
+func NewFloat(f float64) Float {
+	return Float(strconv.FormatFloat(f, 'f', 6, 64))
+}
+
+func (float Float) hasValue() bool {
+	return  float != ""
+}
+
+func (float Float) getValue() (float64, error){
+	return strconv.ParseFloat(string(float), 64)
+}

sdk/requests/types_test.go

@@ -0,0 +1,31 @@
+package requests
+
+import (
+	"testing"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewInteger(t *testing.T) {
+	integer := NewInteger(123123)
+	assert.True(t, integer.hasValue())
+	value, err := integer.getValue()
+	assert.Nil(t, err)
+	assert.Equal(t, value, 123123)
+}
+
+func TestNewBoolean(t *testing.T) {
+	boolean := NewBoolean(false)
+	assert.True(t, boolean.hasValue())
+	value, err := boolean.getValue()
+	assert.Nil(t, err)
+	assert.Equal(t, value, false)
+}
+
+func TestNewFloat(t *testing.T) {
+	float := NewFloat(123123.123123)
+	assert.True(t, float.hasValue())
+	value, err := float.getValue()
+	assert.Nil(t, err)
+	assert.Equal(t, value, 123123.123123)
+}
+

services/alidns/add_batch_domain_records.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,76 +17,78 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddBatchDomainRecords(request *AddBatchDomainRecordsRequest) (response *AddBatchDomainRecordsResponse, err error) {
-	response = CreateAddBatchDomainRecordsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateAddBatchDomainRecordsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) AddBatchDomainRecordsWithChan(request *AddBatchDomainRecordsRequest) (<-chan *AddBatchDomainRecordsResponse, <-chan error) {
-	responseChan := make(chan *AddBatchDomainRecordsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.AddBatchDomainRecords(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *AddBatchDomainRecordsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.AddBatchDomainRecords(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) AddBatchDomainRecordsWithCallback(request *AddBatchDomainRecordsRequest, callback func(response *AddBatchDomainRecordsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *AddBatchDomainRecordsResponse
-		var err error
-		defer close(result)
-		response, err = client.AddBatchDomainRecords(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) AddBatchDomainRecordsWithCallback(request *AddBatchDomainRecordsRequest, callback func(response *AddBatchDomainRecordsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *AddBatchDomainRecordsResponse
+var err error
+defer close(result)
+response, err = client.AddBatchDomainRecords(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type AddBatchDomainRecordsRequest struct {
-	*requests.RpcRequest
-	Records      string `position:"Query" name:"Records"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                Records  string `position:"Query" name:"Records"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type AddBatchDomainRecordsResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId" xml:"RequestId"`
-	TraceId   string `json:"TraceId" xml:"TraceId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            TraceId     string `json:"TraceId" xml:"TraceId"`
 }
 
 func CreateAddBatchDomainRecordsRequest() (request *AddBatchDomainRecordsRequest) {
-	request = &AddBatchDomainRecordsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "AddBatchDomainRecords", "", "")
-	return
+request = &AddBatchDomainRecordsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "AddBatchDomainRecords", "", "")
+return
 }
 
 func CreateAddBatchDomainRecordsResponse() (response *AddBatchDomainRecordsResponse) {
-	response = &AddBatchDomainRecordsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &AddBatchDomainRecordsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/add_domain.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,84 +17,86 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddDomain(request *AddDomainRequest) (response *AddDomainResponse, err error) {
-	response = CreateAddDomainResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateAddDomainResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) AddDomainWithChan(request *AddDomainRequest) (<-chan *AddDomainResponse, <-chan error) {
-	responseChan := make(chan *AddDomainResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.AddDomain(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *AddDomainResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.AddDomain(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) AddDomainWithCallback(request *AddDomainRequest, callback func(response *AddDomainResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *AddDomainResponse
-		var err error
-		defer close(result)
-		response, err = client.AddDomain(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) AddDomainWithCallback(request *AddDomainRequest, callback func(response *AddDomainResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *AddDomainResponse
+var err error
+defer close(result)
+response, err = client.AddDomain(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type AddDomainRequest struct {
-	*requests.RpcRequest
-	DomainName   string `position:"Query" name:"DomainName"`
-	GroupId      string `position:"Query" name:"GroupId"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                GroupId  string `position:"Query" name:"GroupId"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type AddDomainResponse struct {
-	*responses.BaseResponse
-	RequestId  string `json:"RequestId" xml:"RequestId"`
-	DomainId   string `json:"DomainId" xml:"DomainId"`
-	DomainName string `json:"DomainName" xml:"DomainName"`
-	PunyCode   string `json:"PunyCode" xml:"PunyCode"`
-	GroupId    string `json:"GroupId" xml:"GroupId"`
-	GroupName  string `json:"GroupName" xml:"GroupName"`
-	DnsServers struct {
-		DnsServer []string `json:"DnsServer" xml:"DnsServer"`
-	} `json:"DnsServers" xml:"DnsServers"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            DomainId     string `json:"DomainId" xml:"DomainId"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            PunyCode     string `json:"PunyCode" xml:"PunyCode"`
+            GroupId     string `json:"GroupId" xml:"GroupId"`
+            GroupName     string `json:"GroupName" xml:"GroupName"`
+                DnsServers struct {
+                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
+                } `json:"DnsServers" xml:"DnsServers"`
 }
 
 func CreateAddDomainRequest() (request *AddDomainRequest) {
-	request = &AddDomainRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "AddDomain", "", "")
-	return
+request = &AddDomainRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "AddDomain", "", "")
+return
 }
 
 func CreateAddDomainResponse() (response *AddDomainResponse) {
-	response = &AddDomainResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &AddDomainResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/add_domain_group.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,77 +17,79 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddDomainGroup(request *AddDomainGroupRequest) (response *AddDomainGroupResponse, err error) {
-	response = CreateAddDomainGroupResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateAddDomainGroupResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) AddDomainGroupWithChan(request *AddDomainGroupRequest) (<-chan *AddDomainGroupResponse, <-chan error) {
-	responseChan := make(chan *AddDomainGroupResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.AddDomainGroup(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *AddDomainGroupResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.AddDomainGroup(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) AddDomainGroupWithCallback(request *AddDomainGroupRequest, callback func(response *AddDomainGroupResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *AddDomainGroupResponse
-		var err error
-		defer close(result)
-		response, err = client.AddDomainGroup(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) AddDomainGroupWithCallback(request *AddDomainGroupRequest, callback func(response *AddDomainGroupResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *AddDomainGroupResponse
+var err error
+defer close(result)
+response, err = client.AddDomainGroup(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type AddDomainGroupRequest struct {
-	*requests.RpcRequest
-	GroupName    string `position:"Query" name:"GroupName"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                GroupName  string `position:"Query" name:"GroupName"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type AddDomainGroupResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId" xml:"RequestId"`
-	GroupId   string `json:"GroupId" xml:"GroupId"`
-	GroupName string `json:"GroupName" xml:"GroupName"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            GroupId     string `json:"GroupId" xml:"GroupId"`
+            GroupName     string `json:"GroupName" xml:"GroupName"`
 }
 
 func CreateAddDomainGroupRequest() (request *AddDomainGroupRequest) {
-	request = &AddDomainGroupRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "AddDomainGroup", "", "")
-	return
+request = &AddDomainGroupRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "AddDomainGroup", "", "")
+return
 }
 
 func CreateAddDomainGroupResponse() (response *AddDomainGroupResponse) {
-	response = &AddDomainGroupResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &AddDomainGroupResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/add_domain_record.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,82 +17,84 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddDomainRecord(request *AddDomainRecordRequest) (response *AddDomainRecordResponse, err error) {
-	response = CreateAddDomainRecordResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateAddDomainRecordResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) AddDomainRecordWithChan(request *AddDomainRecordRequest) (<-chan *AddDomainRecordResponse, <-chan error) {
-	responseChan := make(chan *AddDomainRecordResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.AddDomainRecord(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *AddDomainRecordResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.AddDomainRecord(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) AddDomainRecordWithCallback(request *AddDomainRecordRequest, callback func(response *AddDomainRecordResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *AddDomainRecordResponse
-		var err error
-		defer close(result)
-		response, err = client.AddDomainRecord(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) AddDomainRecordWithCallback(request *AddDomainRecordRequest, callback func(response *AddDomainRecordResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *AddDomainRecordResponse
+var err error
+defer close(result)
+response, err = client.AddDomainRecord(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type AddDomainRecordRequest struct {
-	*requests.RpcRequest
-	DomainName   string `position:"Query" name:"DomainName"`
-	Priority     string `position:"Query" name:"Priority"`
-	Value        string `position:"Query" name:"Value"`
-	RR           string `position:"Query" name:"RR"`
-	Line         string `position:"Query" name:"Line"`
-	TTL          string `position:"Query" name:"TTL"`
-	Type         string `position:"Query" name:"Type"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                Priority  string `position:"Query" name:"Priority"`
+                Value  string `position:"Query" name:"Value"`
+                RR  string `position:"Query" name:"RR"`
+                Line  string `position:"Query" name:"Line"`
+                TTL  string `position:"Query" name:"TTL"`
+                Type  string `position:"Query" name:"Type"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type AddDomainRecordResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId" xml:"RequestId"`
-	RecordId  string `json:"RecordId" xml:"RecordId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            RecordId     string `json:"RecordId" xml:"RecordId"`
 }
 
 func CreateAddDomainRecordRequest() (request *AddDomainRecordRequest) {
-	request = &AddDomainRecordRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "AddDomainRecord", "", "")
-	return
+request = &AddDomainRecordRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "AddDomainRecord", "", "")
+return
 }
 
 func CreateAddDomainRecordResponse() (response *AddDomainRecordResponse) {
-	response = &AddDomainRecordResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &AddDomainRecordResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/apply_for_retrieval_domain_name.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,76 +17,78 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ApplyForRetrievalDomainName(request *ApplyForRetrievalDomainNameRequest) (response *ApplyForRetrievalDomainNameResponse, err error) {
-	response = CreateApplyForRetrievalDomainNameResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateApplyForRetrievalDomainNameResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ApplyForRetrievalDomainNameWithChan(request *ApplyForRetrievalDomainNameRequest) (<-chan *ApplyForRetrievalDomainNameResponse, <-chan error) {
-	responseChan := make(chan *ApplyForRetrievalDomainNameResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ApplyForRetrievalDomainName(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ApplyForRetrievalDomainNameResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ApplyForRetrievalDomainName(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ApplyForRetrievalDomainNameWithCallback(request *ApplyForRetrievalDomainNameRequest, callback func(response *ApplyForRetrievalDomainNameResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ApplyForRetrievalDomainNameResponse
-		var err error
-		defer close(result)
-		response, err = client.ApplyForRetrievalDomainName(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ApplyForRetrievalDomainNameWithCallback(request *ApplyForRetrievalDomainNameRequest, callback func(response *ApplyForRetrievalDomainNameResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ApplyForRetrievalDomainNameResponse
+var err error
+defer close(result)
+response, err = client.ApplyForRetrievalDomainName(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ApplyForRetrievalDomainNameRequest struct {
-	*requests.RpcRequest
-	DomainName   string `position:"Query" name:"DomainName"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type ApplyForRetrievalDomainNameResponse struct {
-	*responses.BaseResponse
-	RequestId  string `json:"RequestId" xml:"RequestId"`
-	DomainName string `json:"DomainName" xml:"DomainName"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
 }
 
 func CreateApplyForRetrievalDomainNameRequest() (request *ApplyForRetrievalDomainNameRequest) {
-	request = &ApplyForRetrievalDomainNameRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "ApplyForRetrievalDomainName", "", "")
-	return
+request = &ApplyForRetrievalDomainNameRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "ApplyForRetrievalDomainName", "", "")
+return
 }
 
 func CreateApplyForRetrievalDomainNameResponse() (response *ApplyForRetrievalDomainNameResponse) {
-	response = &ApplyForRetrievalDomainNameResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ApplyForRetrievalDomainNameResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/change_domain_group.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,78 +17,80 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ChangeDomainGroup(request *ChangeDomainGroupRequest) (response *ChangeDomainGroupResponse, err error) {
-	response = CreateChangeDomainGroupResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateChangeDomainGroupResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ChangeDomainGroupWithChan(request *ChangeDomainGroupRequest) (<-chan *ChangeDomainGroupResponse, <-chan error) {
-	responseChan := make(chan *ChangeDomainGroupResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ChangeDomainGroup(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ChangeDomainGroupResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ChangeDomainGroup(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ChangeDomainGroupWithCallback(request *ChangeDomainGroupRequest, callback func(response *ChangeDomainGroupResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ChangeDomainGroupResponse
-		var err error
-		defer close(result)
-		response, err = client.ChangeDomainGroup(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ChangeDomainGroupWithCallback(request *ChangeDomainGroupRequest, callback func(response *ChangeDomainGroupResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ChangeDomainGroupResponse
+var err error
+defer close(result)
+response, err = client.ChangeDomainGroup(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ChangeDomainGroupRequest struct {
-	*requests.RpcRequest
-	DomainName   string `position:"Query" name:"DomainName"`
-	GroupId      string `position:"Query" name:"GroupId"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                GroupId  string `position:"Query" name:"GroupId"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type ChangeDomainGroupResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId" xml:"RequestId"`
-	GroupId   string `json:"GroupId" xml:"GroupId"`
-	GroupName string `json:"GroupName" xml:"GroupName"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            GroupId     string `json:"GroupId" xml:"GroupId"`
+            GroupName     string `json:"GroupName" xml:"GroupName"`
 }
 
 func CreateChangeDomainGroupRequest() (request *ChangeDomainGroupRequest) {
-	request = &ChangeDomainGroupRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "ChangeDomainGroup", "", "")
-	return
+request = &ChangeDomainGroupRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "ChangeDomainGroup", "", "")
+return
 }
 
 func CreateChangeDomainGroupResponse() (response *ChangeDomainGroupResponse) {
-	response = &ChangeDomainGroupResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ChangeDomainGroupResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/change_domain_of_dns_product.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,78 +17,80 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ChangeDomainOfDnsProduct(request *ChangeDomainOfDnsProductRequest) (response *ChangeDomainOfDnsProductResponse, err error) {
-	response = CreateChangeDomainOfDnsProductResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateChangeDomainOfDnsProductResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ChangeDomainOfDnsProductWithChan(request *ChangeDomainOfDnsProductRequest) (<-chan *ChangeDomainOfDnsProductResponse, <-chan error) {
-	responseChan := make(chan *ChangeDomainOfDnsProductResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ChangeDomainOfDnsProduct(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ChangeDomainOfDnsProductResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ChangeDomainOfDnsProduct(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ChangeDomainOfDnsProductWithCallback(request *ChangeDomainOfDnsProductRequest, callback func(response *ChangeDomainOfDnsProductResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ChangeDomainOfDnsProductResponse
-		var err error
-		defer close(result)
-		response, err = client.ChangeDomainOfDnsProduct(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ChangeDomainOfDnsProductWithCallback(request *ChangeDomainOfDnsProductRequest, callback func(response *ChangeDomainOfDnsProductResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ChangeDomainOfDnsProductResponse
+var err error
+defer close(result)
+response, err = client.ChangeDomainOfDnsProduct(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ChangeDomainOfDnsProductRequest struct {
-	*requests.RpcRequest
-	NewDomain    string `position:"Query" name:"NewDomain"`
-	Force        string `position:"Query" name:"Force"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
-	InstanceId   string `position:"Query" name:"InstanceId"`
+*requests.RpcRequest
+                NewDomain  string `position:"Query" name:"NewDomain"`
+                Force  string `position:"Query" name:"Force"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type ChangeDomainOfDnsProductResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId" xml:"RequestId"`
-	OriginalDomain string `json:"OriginalDomain" xml:"OriginalDomain"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            OriginalDomain     string `json:"OriginalDomain" xml:"OriginalDomain"`
 }
 
 func CreateChangeDomainOfDnsProductRequest() (request *ChangeDomainOfDnsProductRequest) {
-	request = &ChangeDomainOfDnsProductRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "ChangeDomainOfDnsProduct", "", "")
-	return
+request = &ChangeDomainOfDnsProductRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "ChangeDomainOfDnsProduct", "", "")
+return
 }
 
 func CreateChangeDomainOfDnsProductResponse() (response *ChangeDomainOfDnsProductResponse) {
-	response = &ChangeDomainOfDnsProductResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ChangeDomainOfDnsProductResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/check_domain_record.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,79 +17,81 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) CheckDomainRecord(request *CheckDomainRecordRequest) (response *CheckDomainRecordResponse, err error) {
-	response = CreateCheckDomainRecordResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateCheckDomainRecordResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) CheckDomainRecordWithChan(request *CheckDomainRecordRequest) (<-chan *CheckDomainRecordResponse, <-chan error) {
-	responseChan := make(chan *CheckDomainRecordResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.CheckDomainRecord(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *CheckDomainRecordResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.CheckDomainRecord(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) CheckDomainRecordWithCallback(request *CheckDomainRecordRequest, callback func(response *CheckDomainRecordResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *CheckDomainRecordResponse
-		var err error
-		defer close(result)
-		response, err = client.CheckDomainRecord(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) CheckDomainRecordWithCallback(request *CheckDomainRecordRequest, callback func(response *CheckDomainRecordResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *CheckDomainRecordResponse
+var err error
+defer close(result)
+response, err = client.CheckDomainRecord(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type CheckDomainRecordRequest struct {
-	*requests.RpcRequest
-	DomainName   string `position:"Query" name:"DomainName"`
-	Value        string `position:"Query" name:"Value"`
-	RR           string `position:"Query" name:"RR"`
-	Type         string `position:"Query" name:"Type"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                Value  string `position:"Query" name:"Value"`
+                RR  string `position:"Query" name:"RR"`
+                Type  string `position:"Query" name:"Type"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type CheckDomainRecordResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId" xml:"RequestId"`
-	IsExist   bool   `json:"IsExist" xml:"IsExist"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            IsExist     bool `json:"IsExist" xml:"IsExist"`
 }
 
 func CreateCheckDomainRecordRequest() (request *CheckDomainRecordRequest) {
-	request = &CheckDomainRecordRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "CheckDomainRecord", "", "")
-	return
+request = &CheckDomainRecordRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "CheckDomainRecord", "", "")
+return
 }
 
 func CreateCheckDomainRecordResponse() (response *CheckDomainRecordResponse) {
-	response = &CheckDomainRecordResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &CheckDomainRecordResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/client.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,28 +17,28 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth"
+    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
+    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth"
 )
 
 type Client struct {
-	sdk.Client
+    sdk.Client
 }
 
 func NewClient() (client *Client, err error) {
-	client = &Client{}
-	err = client.Init()
-	return
+    client = &Client{}
+    err = client.Init()
+    return
 }
 
 func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error) {
-	client = &Client{}
-	err = client.InitWithOptions(regionId, config, credential)
-	return
+    client = &Client{}
+    err = client.InitWithOptions(regionId, config, credential)
+    return
 }
 
 func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error) {
-	client = &Client{}
-	err = client.InitWithAccessKey(regionId, accessKeyId, accessKeySecret)
-	return
+    client = &Client{}
+    err = client.InitWithAccessKey(regionId, accessKeyId, accessKeySecret)
+    return
 }

services/alidns/delete_batch_domain_records.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,76 +17,78 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteBatchDomainRecords(request *DeleteBatchDomainRecordsRequest) (response *DeleteBatchDomainRecordsResponse, err error) {
-	response = CreateDeleteBatchDomainRecordsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDeleteBatchDomainRecordsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DeleteBatchDomainRecordsWithChan(request *DeleteBatchDomainRecordsRequest) (<-chan *DeleteBatchDomainRecordsResponse, <-chan error) {
-	responseChan := make(chan *DeleteBatchDomainRecordsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DeleteBatchDomainRecords(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DeleteBatchDomainRecordsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DeleteBatchDomainRecords(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DeleteBatchDomainRecordsWithCallback(request *DeleteBatchDomainRecordsRequest, callback func(response *DeleteBatchDomainRecordsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DeleteBatchDomainRecordsResponse
-		var err error
-		defer close(result)
-		response, err = client.DeleteBatchDomainRecords(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DeleteBatchDomainRecordsWithCallback(request *DeleteBatchDomainRecordsRequest, callback func(response *DeleteBatchDomainRecordsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DeleteBatchDomainRecordsResponse
+var err error
+defer close(result)
+response, err = client.DeleteBatchDomainRecords(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DeleteBatchDomainRecordsRequest struct {
-	*requests.RpcRequest
-	Records      string `position:"Query" name:"Records"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                Records  string `position:"Query" name:"Records"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DeleteBatchDomainRecordsResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId" xml:"RequestId"`
-	TraceId   string `json:"TraceId" xml:"TraceId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            TraceId     string `json:"TraceId" xml:"TraceId"`
 }
 
 func CreateDeleteBatchDomainRecordsRequest() (request *DeleteBatchDomainRecordsRequest) {
-	request = &DeleteBatchDomainRecordsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteBatchDomainRecords", "", "")
-	return
+request = &DeleteBatchDomainRecordsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteBatchDomainRecords", "", "")
+return
 }
 
 func CreateDeleteBatchDomainRecordsResponse() (response *DeleteBatchDomainRecordsResponse) {
-	response = &DeleteBatchDomainRecordsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DeleteBatchDomainRecordsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/delete_batch_domains.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,76 +17,78 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteBatchDomains(request *DeleteBatchDomainsRequest) (response *DeleteBatchDomainsResponse, err error) {
-	response = CreateDeleteBatchDomainsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDeleteBatchDomainsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DeleteBatchDomainsWithChan(request *DeleteBatchDomainsRequest) (<-chan *DeleteBatchDomainsResponse, <-chan error) {
-	responseChan := make(chan *DeleteBatchDomainsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DeleteBatchDomains(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DeleteBatchDomainsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DeleteBatchDomains(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DeleteBatchDomainsWithCallback(request *DeleteBatchDomainsRequest, callback func(response *DeleteBatchDomainsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DeleteBatchDomainsResponse
-		var err error
-		defer close(result)
-		response, err = client.DeleteBatchDomains(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DeleteBatchDomainsWithCallback(request *DeleteBatchDomainsRequest, callback func(response *DeleteBatchDomainsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DeleteBatchDomainsResponse
+var err error
+defer close(result)
+response, err = client.DeleteBatchDomains(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DeleteBatchDomainsRequest struct {
-	*requests.RpcRequest
-	Domains      string `position:"Query" name:"Domains"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                Domains  string `position:"Query" name:"Domains"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DeleteBatchDomainsResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId" xml:"RequestId"`
-	TraceId   string `json:"TraceId" xml:"TraceId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            TraceId     string `json:"TraceId" xml:"TraceId"`
 }
 
 func CreateDeleteBatchDomainsRequest() (request *DeleteBatchDomainsRequest) {
-	request = &DeleteBatchDomainsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteBatchDomains", "", "")
-	return
+request = &DeleteBatchDomainsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteBatchDomains", "", "")
+return
 }
 
 func CreateDeleteBatchDomainsResponse() (response *DeleteBatchDomainsResponse) {
-	response = &DeleteBatchDomainsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DeleteBatchDomainsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/delete_domain.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,76 +17,78 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteDomain(request *DeleteDomainRequest) (response *DeleteDomainResponse, err error) {
-	response = CreateDeleteDomainResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDeleteDomainResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DeleteDomainWithChan(request *DeleteDomainRequest) (<-chan *DeleteDomainResponse, <-chan error) {
-	responseChan := make(chan *DeleteDomainResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DeleteDomain(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DeleteDomainResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DeleteDomain(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DeleteDomainWithCallback(request *DeleteDomainRequest, callback func(response *DeleteDomainResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DeleteDomainResponse
-		var err error
-		defer close(result)
-		response, err = client.DeleteDomain(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DeleteDomainWithCallback(request *DeleteDomainRequest, callback func(response *DeleteDomainResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DeleteDomainResponse
+var err error
+defer close(result)
+response, err = client.DeleteDomain(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DeleteDomainRequest struct {
-	*requests.RpcRequest
-	DomainName   string `position:"Query" name:"DomainName"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DeleteDomainResponse struct {
-	*responses.BaseResponse
-	RequestId  string `json:"RequestId" xml:"RequestId"`
-	DomainName string `json:"DomainName" xml:"DomainName"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
 }
 
 func CreateDeleteDomainRequest() (request *DeleteDomainRequest) {
-	request = &DeleteDomainRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteDomain", "", "")
-	return
+request = &DeleteDomainRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteDomain", "", "")
+return
 }
 
 func CreateDeleteDomainResponse() (response *DeleteDomainResponse) {
-	response = &DeleteDomainResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DeleteDomainResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/delete_domain_group.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,76 +17,78 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteDomainGroup(request *DeleteDomainGroupRequest) (response *DeleteDomainGroupResponse, err error) {
-	response = CreateDeleteDomainGroupResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDeleteDomainGroupResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DeleteDomainGroupWithChan(request *DeleteDomainGroupRequest) (<-chan *DeleteDomainGroupResponse, <-chan error) {
-	responseChan := make(chan *DeleteDomainGroupResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DeleteDomainGroup(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DeleteDomainGroupResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DeleteDomainGroup(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DeleteDomainGroupWithCallback(request *DeleteDomainGroupRequest, callback func(response *DeleteDomainGroupResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DeleteDomainGroupResponse
-		var err error
-		defer close(result)
-		response, err = client.DeleteDomainGroup(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DeleteDomainGroupWithCallback(request *DeleteDomainGroupRequest, callback func(response *DeleteDomainGroupResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DeleteDomainGroupResponse
+var err error
+defer close(result)
+response, err = client.DeleteDomainGroup(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DeleteDomainGroupRequest struct {
-	*requests.RpcRequest
-	GroupId      string `position:"Query" name:"GroupId"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                GroupId  string `position:"Query" name:"GroupId"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DeleteDomainGroupResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId" xml:"RequestId"`
-	GroupName string `json:"GroupName" xml:"GroupName"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            GroupName     string `json:"GroupName" xml:"GroupName"`
 }
 
 func CreateDeleteDomainGroupRequest() (request *DeleteDomainGroupRequest) {
-	request = &DeleteDomainGroupRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteDomainGroup", "", "")
-	return
+request = &DeleteDomainGroupRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteDomainGroup", "", "")
+return
 }
 
 func CreateDeleteDomainGroupResponse() (response *DeleteDomainGroupResponse) {
-	response = &DeleteDomainGroupResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DeleteDomainGroupResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/delete_domain_record.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,76 +17,78 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteDomainRecord(request *DeleteDomainRecordRequest) (response *DeleteDomainRecordResponse, err error) {
-	response = CreateDeleteDomainRecordResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDeleteDomainRecordResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DeleteDomainRecordWithChan(request *DeleteDomainRecordRequest) (<-chan *DeleteDomainRecordResponse, <-chan error) {
-	responseChan := make(chan *DeleteDomainRecordResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DeleteDomainRecord(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DeleteDomainRecordResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DeleteDomainRecord(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DeleteDomainRecordWithCallback(request *DeleteDomainRecordRequest, callback func(response *DeleteDomainRecordResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DeleteDomainRecordResponse
-		var err error
-		defer close(result)
-		response, err = client.DeleteDomainRecord(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DeleteDomainRecordWithCallback(request *DeleteDomainRecordRequest, callback func(response *DeleteDomainRecordResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DeleteDomainRecordResponse
+var err error
+defer close(result)
+response, err = client.DeleteDomainRecord(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DeleteDomainRecordRequest struct {
-	*requests.RpcRequest
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
-	RecordId     string `position:"Query" name:"RecordId"`
+*requests.RpcRequest
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
+                RecordId  string `position:"Query" name:"RecordId"`
 }
 
+
 type DeleteDomainRecordResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId" xml:"RequestId"`
-	RecordId  string `json:"RecordId" xml:"RecordId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            RecordId     string `json:"RecordId" xml:"RecordId"`
 }
 
 func CreateDeleteDomainRecordRequest() (request *DeleteDomainRecordRequest) {
-	request = &DeleteDomainRecordRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteDomainRecord", "", "")
-	return
+request = &DeleteDomainRecordRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteDomainRecord", "", "")
+return
 }
 
 func CreateDeleteDomainRecordResponse() (response *DeleteDomainRecordResponse) {
-	response = &DeleteDomainRecordResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DeleteDomainRecordResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/delete_sub_domain_records.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,79 +17,81 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteSubDomainRecords(request *DeleteSubDomainRecordsRequest) (response *DeleteSubDomainRecordsResponse, err error) {
-	response = CreateDeleteSubDomainRecordsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDeleteSubDomainRecordsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DeleteSubDomainRecordsWithChan(request *DeleteSubDomainRecordsRequest) (<-chan *DeleteSubDomainRecordsResponse, <-chan error) {
-	responseChan := make(chan *DeleteSubDomainRecordsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DeleteSubDomainRecords(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DeleteSubDomainRecordsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DeleteSubDomainRecords(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DeleteSubDomainRecordsWithCallback(request *DeleteSubDomainRecordsRequest, callback func(response *DeleteSubDomainRecordsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DeleteSubDomainRecordsResponse
-		var err error
-		defer close(result)
-		response, err = client.DeleteSubDomainRecords(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DeleteSubDomainRecordsWithCallback(request *DeleteSubDomainRecordsRequest, callback func(response *DeleteSubDomainRecordsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DeleteSubDomainRecordsResponse
+var err error
+defer close(result)
+response, err = client.DeleteSubDomainRecords(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DeleteSubDomainRecordsRequest struct {
-	*requests.RpcRequest
-	DomainName   string `position:"Query" name:"DomainName"`
-	RR           string `position:"Query" name:"RR"`
-	Type         string `position:"Query" name:"Type"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                RR  string `position:"Query" name:"RR"`
+                Type  string `position:"Query" name:"Type"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DeleteSubDomainRecordsResponse struct {
-	*responses.BaseResponse
-	RequestId  string `json:"RequestId" xml:"RequestId"`
-	RR         string `json:"RR" xml:"RR"`
-	TotalCount string `json:"TotalCount" xml:"TotalCount"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            RR     string `json:"RR" xml:"RR"`
+            TotalCount     string `json:"TotalCount" xml:"TotalCount"`
 }
 
 func CreateDeleteSubDomainRecordsRequest() (request *DeleteSubDomainRecordsRequest) {
-	request = &DeleteSubDomainRecordsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteSubDomainRecords", "", "")
-	return
+request = &DeleteSubDomainRecordsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteSubDomainRecords", "", "")
+return
 }
 
 func CreateDeleteSubDomainRecordsResponse() (response *DeleteSubDomainRecordsResponse) {
-	response = &DeleteSubDomainRecordsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DeleteSubDomainRecordsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/describe_batch_result.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,85 +17,87 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeBatchResult(request *DescribeBatchResultRequest) (response *DescribeBatchResultResponse, err error) {
-	response = CreateDescribeBatchResultResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeBatchResultResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeBatchResultWithChan(request *DescribeBatchResultRequest) (<-chan *DescribeBatchResultResponse, <-chan error) {
-	responseChan := make(chan *DescribeBatchResultResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeBatchResult(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeBatchResultResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeBatchResult(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeBatchResultWithCallback(request *DescribeBatchResultRequest, callback func(response *DescribeBatchResultResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeBatchResultResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeBatchResult(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeBatchResultWithCallback(request *DescribeBatchResultRequest, callback func(response *DescribeBatchResultResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeBatchResultResponse
+var err error
+defer close(result)
+response, err = client.DescribeBatchResult(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeBatchResultRequest struct {
-	*requests.RpcRequest
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
-	TraceId      string `position:"Query" name:"TraceId"`
+*requests.RpcRequest
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
+                TraceId  string `position:"Query" name:"TraceId"`
 }
 
+
 type DescribeBatchResultResponse struct {
-	*responses.BaseResponse
-	RequestId     string `json:"RequestId" xml:"RequestId"`
-	TraceId       string `json:"TraceId" xml:"TraceId"`
-	Status        int64  `json:"Status" xml:"Status"`
-	BatchCount    int64  `json:"BatchCount" xml:"BatchCount"`
-	SuccessNumber int64  `json:"SuccessNumber" xml:"SuccessNumber"`
-	FailResults   struct {
-		FailResult []struct {
-			BatchIndex string `json:"BatchIndex" xml:"BatchIndex"`
-			ErrorCode  string `json:"ErrorCode" xml:"ErrorCode"`
-		} `json:"FailResult" xml:"FailResult"`
-	} `json:"FailResults" xml:"FailResults"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            TraceId     string `json:"TraceId" xml:"TraceId"`
+            Status     int64 `json:"Status" xml:"Status"`
+            BatchCount     int64 `json:"BatchCount" xml:"BatchCount"`
+            SuccessNumber     int64 `json:"SuccessNumber" xml:"SuccessNumber"`
+                FailResults struct {
+                    FailResult []struct {
+            BatchIndex     string `json:"BatchIndex" xml:"BatchIndex"`
+            ErrorCode     string `json:"ErrorCode" xml:"ErrorCode"`
+                    }   `json:"FailResult" xml:"FailResult"`
+                } `json:"FailResults" xml:"FailResults"`
 }
 
 func CreateDescribeBatchResultRequest() (request *DescribeBatchResultRequest) {
-	request = &DescribeBatchResultRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeBatchResult", "", "")
-	return
+request = &DescribeBatchResultRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeBatchResult", "", "")
+return
 }
 
 func CreateDescribeBatchResultResponse() (response *DescribeBatchResultResponse) {
-	response = &DescribeBatchResultResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeBatchResultResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/describe_d_n_s_s_l_b_sub_domains.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,88 +17,90 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDNSSLBSubDomains(request *DescribeDNSSLBSubDomainsRequest) (response *DescribeDNSSLBSubDomainsResponse, err error) {
-	response = CreateDescribeDNSSLBSubDomainsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeDNSSLBSubDomainsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeDNSSLBSubDomainsWithChan(request *DescribeDNSSLBSubDomainsRequest) (<-chan *DescribeDNSSLBSubDomainsResponse, <-chan error) {
-	responseChan := make(chan *DescribeDNSSLBSubDomainsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeDNSSLBSubDomains(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeDNSSLBSubDomainsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeDNSSLBSubDomains(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeDNSSLBSubDomainsWithCallback(request *DescribeDNSSLBSubDomainsRequest, callback func(response *DescribeDNSSLBSubDomainsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeDNSSLBSubDomainsResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeDNSSLBSubDomains(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeDNSSLBSubDomainsWithCallback(request *DescribeDNSSLBSubDomainsRequest, callback func(response *DescribeDNSSLBSubDomainsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeDNSSLBSubDomainsResponse
+var err error
+defer close(result)
+response, err = client.DescribeDNSSLBSubDomains(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeDNSSLBSubDomainsRequest struct {
-	*requests.RpcRequest
-	PageSize     string `position:"Query" name:"PageSize"`
-	DomainName   string `position:"Query" name:"DomainName"`
-	PageNumber   string `position:"Query" name:"PageNumber"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                PageSize  string `position:"Query" name:"PageSize"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                PageNumber  string `position:"Query" name:"PageNumber"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DescribeDNSSLBSubDomainsResponse struct {
-	*responses.BaseResponse
-	RequestId     string `json:"RequestId" xml:"RequestId"`
-	TotalCount    int64  `json:"TotalCount" xml:"TotalCount"`
-	PageNumber    int64  `json:"PageNumber" xml:"PageNumber"`
-	PageSize      int64  `json:"PageSize" xml:"PageSize"`
-	SlbSubDomains struct {
-		SlbSubDomain []struct {
-			SubDomain   string `json:"SubDomain" xml:"SubDomain"`
-			RecordCount int64  `json:"RecordCount" xml:"RecordCount"`
-			Open        bool   `json:"Open" xml:"Open"`
-			Type        string `json:"Type" xml:"Type"`
-		} `json:"SlbSubDomain" xml:"SlbSubDomain"`
-	} `json:"SlbSubDomains" xml:"SlbSubDomains"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
+            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
+            PageSize     int64 `json:"PageSize" xml:"PageSize"`
+                SlbSubDomains struct {
+                    SlbSubDomain []struct {
+            SubDomain     string `json:"SubDomain" xml:"SubDomain"`
+            RecordCount     int64 `json:"RecordCount" xml:"RecordCount"`
+            Open     bool `json:"Open" xml:"Open"`
+            Type     string `json:"Type" xml:"Type"`
+                    }   `json:"SlbSubDomain" xml:"SlbSubDomain"`
+                } `json:"SlbSubDomains" xml:"SlbSubDomains"`
 }
 
 func CreateDescribeDNSSLBSubDomainsRequest() (request *DescribeDNSSLBSubDomainsRequest) {
-	request = &DescribeDNSSLBSubDomainsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDNSSLBSubDomains", "", "")
-	return
+request = &DescribeDNSSLBSubDomainsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDNSSLBSubDomains", "", "")
+return
 }
 
 func CreateDescribeDNSSLBSubDomainsResponse() (response *DescribeDNSSLBSubDomainsResponse) {
-	response = &DescribeDNSSLBSubDomainsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeDNSSLBSubDomainsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/describe_dns_product_instance.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,106 +17,108 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDnsProductInstance(request *DescribeDnsProductInstanceRequest) (response *DescribeDnsProductInstanceResponse, err error) {
-	response = CreateDescribeDnsProductInstanceResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeDnsProductInstanceResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeDnsProductInstanceWithChan(request *DescribeDnsProductInstanceRequest) (<-chan *DescribeDnsProductInstanceResponse, <-chan error) {
-	responseChan := make(chan *DescribeDnsProductInstanceResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeDnsProductInstance(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeDnsProductInstanceResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeDnsProductInstance(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeDnsProductInstanceWithCallback(request *DescribeDnsProductInstanceRequest, callback func(response *DescribeDnsProductInstanceResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeDnsProductInstanceResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeDnsProductInstance(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeDnsProductInstanceWithCallback(request *DescribeDnsProductInstanceRequest, callback func(response *DescribeDnsProductInstanceResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeDnsProductInstanceResponse
+var err error
+defer close(result)
+response, err = client.DescribeDnsProductInstance(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeDnsProductInstanceRequest struct {
-	*requests.RpcRequest
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
-	InstanceId   string `position:"Query" name:"InstanceId"`
+*requests.RpcRequest
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type DescribeDnsProductInstanceResponse struct {
-	*responses.BaseResponse
-	RequestId             string `json:"RequestId" xml:"RequestId"`
-	InstanceId            string `json:"InstanceId" xml:"InstanceId"`
-	VersionCode           string `json:"VersionCode" xml:"VersionCode"`
-	VersionName           string `json:"VersionName" xml:"VersionName"`
-	StartTime             string `json:"StartTime" xml:"StartTime"`
-	StartTimestamp        int64  `json:"StartTimestamp" xml:"StartTimestamp"`
-	EndTime               string `json:"EndTime" xml:"EndTime"`
-	EndTimestamp          int64  `json:"EndTimestamp" xml:"EndTimestamp"`
-	Domain                string `json:"Domain" xml:"Domain"`
-	BindCount             int64  `json:"BindCount" xml:"BindCount"`
-	BindUsedCount         int64  `json:"BindUsedCount" xml:"BindUsedCount"`
-	TTLMinValue           int64  `json:"TTLMinValue" xml:"TTLMinValue"`
-	SubDomainLevel        int64  `json:"SubDomainLevel" xml:"SubDomainLevel"`
-	DnsSLBCount           int64  `json:"DnsSLBCount" xml:"DnsSLBCount"`
-	URLForwardCount       int64  `json:"URLForwardCount" xml:"URLForwardCount"`
-	DDosDefendFlow        int64  `json:"DDosDefendFlow" xml:"DDosDefendFlow"`
-	DDosDefendQuery       int64  `json:"DDosDefendQuery" xml:"DDosDefendQuery"`
-	OverseaDDosDefendFlow int64  `json:"OverseaDDosDefendFlow" xml:"OverseaDDosDefendFlow"`
-	SearchEngineLines     string `json:"SearchEngineLines" xml:"SearchEngineLines"`
-	ISPLines              string `json:"ISPLines" xml:"ISPLines"`
-	ISPRegionLines        string `json:"ISPRegionLines" xml:"ISPRegionLines"`
-	OverseaLine           string `json:"OverseaLine" xml:"OverseaLine"`
-	MonitorNodeCount      int64  `json:"MonitorNodeCount" xml:"MonitorNodeCount"`
-	MonitorFrequency      int64  `json:"MonitorFrequency" xml:"MonitorFrequency"`
-	MonitorTaskCount      int64  `json:"MonitorTaskCount" xml:"MonitorTaskCount"`
-	RegionLines           bool   `json:"RegionLines" xml:"RegionLines"`
-	Gslb                  bool   `json:"Gslb" xml:"Gslb"`
-	InClean               bool   `json:"InClean" xml:"InClean"`
-	InBlackHole           bool   `json:"InBlackHole" xml:"InBlackHole"`
-	DnsServers            struct {
-		DnsServer []string `json:"DnsServer" xml:"DnsServer"`
-	} `json:"DnsServers" xml:"DnsServers"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            VersionCode     string `json:"VersionCode" xml:"VersionCode"`
+            VersionName     string `json:"VersionName" xml:"VersionName"`
+            StartTime     string `json:"StartTime" xml:"StartTime"`
+            StartTimestamp     int64 `json:"StartTimestamp" xml:"StartTimestamp"`
+            EndTime     string `json:"EndTime" xml:"EndTime"`
+            EndTimestamp     int64 `json:"EndTimestamp" xml:"EndTimestamp"`
+            Domain     string `json:"Domain" xml:"Domain"`
+            BindCount     int64 `json:"BindCount" xml:"BindCount"`
+            BindUsedCount     int64 `json:"BindUsedCount" xml:"BindUsedCount"`
+            TTLMinValue     int64 `json:"TTLMinValue" xml:"TTLMinValue"`
+            SubDomainLevel     int64 `json:"SubDomainLevel" xml:"SubDomainLevel"`
+            DnsSLBCount     int64 `json:"DnsSLBCount" xml:"DnsSLBCount"`
+            URLForwardCount     int64 `json:"URLForwardCount" xml:"URLForwardCount"`
+            DDosDefendFlow     int64 `json:"DDosDefendFlow" xml:"DDosDefendFlow"`
+            DDosDefendQuery     int64 `json:"DDosDefendQuery" xml:"DDosDefendQuery"`
+            OverseaDDosDefendFlow     int64 `json:"OverseaDDosDefendFlow" xml:"OverseaDDosDefendFlow"`
+            SearchEngineLines     string `json:"SearchEngineLines" xml:"SearchEngineLines"`
+            ISPLines     string `json:"ISPLines" xml:"ISPLines"`
+            ISPRegionLines     string `json:"ISPRegionLines" xml:"ISPRegionLines"`
+            OverseaLine     string `json:"OverseaLine" xml:"OverseaLine"`
+            MonitorNodeCount     int64 `json:"MonitorNodeCount" xml:"MonitorNodeCount"`
+            MonitorFrequency     int64 `json:"MonitorFrequency" xml:"MonitorFrequency"`
+            MonitorTaskCount     int64 `json:"MonitorTaskCount" xml:"MonitorTaskCount"`
+            RegionLines     bool `json:"RegionLines" xml:"RegionLines"`
+            Gslb     bool `json:"Gslb" xml:"Gslb"`
+            InClean     bool `json:"InClean" xml:"InClean"`
+            InBlackHole     bool `json:"InBlackHole" xml:"InBlackHole"`
+                DnsServers struct {
+                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
+                } `json:"DnsServers" xml:"DnsServers"`
 }
 
 func CreateDescribeDnsProductInstanceRequest() (request *DescribeDnsProductInstanceRequest) {
-	request = &DescribeDnsProductInstanceRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDnsProductInstance", "", "")
-	return
+request = &DescribeDnsProductInstanceRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDnsProductInstance", "", "")
+return
 }
 
 func CreateDescribeDnsProductInstanceResponse() (response *DescribeDnsProductInstanceResponse) {
-	response = &DescribeDnsProductInstanceResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeDnsProductInstanceResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/describe_dns_product_instances.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,112 +17,114 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDnsProductInstances(request *DescribeDnsProductInstancesRequest) (response *DescribeDnsProductInstancesResponse, err error) {
-	response = CreateDescribeDnsProductInstancesResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeDnsProductInstancesResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeDnsProductInstancesWithChan(request *DescribeDnsProductInstancesRequest) (<-chan *DescribeDnsProductInstancesResponse, <-chan error) {
-	responseChan := make(chan *DescribeDnsProductInstancesResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeDnsProductInstances(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeDnsProductInstancesResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeDnsProductInstances(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeDnsProductInstancesWithCallback(request *DescribeDnsProductInstancesRequest, callback func(response *DescribeDnsProductInstancesResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeDnsProductInstancesResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeDnsProductInstances(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeDnsProductInstancesWithCallback(request *DescribeDnsProductInstancesRequest, callback func(response *DescribeDnsProductInstancesResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeDnsProductInstancesResponse
+var err error
+defer close(result)
+response, err = client.DescribeDnsProductInstances(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeDnsProductInstancesRequest struct {
-	*requests.RpcRequest
-	PageSize     string `position:"Query" name:"PageSize"`
-	PageNumber   string `position:"Query" name:"PageNumber"`
-	VersionCode  string `position:"Query" name:"VersionCode"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                PageSize  string `position:"Query" name:"PageSize"`
+                PageNumber  string `position:"Query" name:"PageNumber"`
+                VersionCode  string `position:"Query" name:"VersionCode"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DescribeDnsProductInstancesResponse struct {
-	*responses.BaseResponse
-	RequestId   string `json:"RequestId" xml:"RequestId"`
-	TotalCount  int64  `json:"TotalCount" xml:"TotalCount"`
-	PageNumber  int64  `json:"PageNumber" xml:"PageNumber"`
-	PageSize    int64  `json:"PageSize" xml:"PageSize"`
-	DnsProducts struct {
-		DnsProduct []struct {
-			InstanceId            string `json:"InstanceId" xml:"InstanceId"`
-			VersionCode           string `json:"VersionCode" xml:"VersionCode"`
-			VersionName           string `json:"VersionName" xml:"VersionName"`
-			StartTime             string `json:"StartTime" xml:"StartTime"`
-			EndTime               string `json:"EndTime" xml:"EndTime"`
-			StartTimestamp        int64  `json:"StartTimestamp" xml:"StartTimestamp"`
-			EndTimestamp          int64  `json:"EndTimestamp" xml:"EndTimestamp"`
-			Domain                string `json:"Domain" xml:"Domain"`
-			BindCount             int64  `json:"BindCount" xml:"BindCount"`
-			BindUsedCount         int64  `json:"BindUsedCount" xml:"BindUsedCount"`
-			TTLMinValue           int64  `json:"TTLMinValue" xml:"TTLMinValue"`
-			SubDomainLevel        int64  `json:"SubDomainLevel" xml:"SubDomainLevel"`
-			DnsSLBCount           int64  `json:"DnsSLBCount" xml:"DnsSLBCount"`
-			URLForwardCount       int64  `json:"URLForwardCount" xml:"URLForwardCount"`
-			DDosDefendFlow        int64  `json:"DDosDefendFlow" xml:"DDosDefendFlow"`
-			DDosDefendQuery       int64  `json:"DDosDefendQuery" xml:"DDosDefendQuery"`
-			OverseaDDosDefendFlow int64  `json:"OverseaDDosDefendFlow" xml:"OverseaDDosDefendFlow"`
-			SearchEngineLines     string `json:"SearchEngineLines" xml:"SearchEngineLines"`
-			ISPLines              string `json:"ISPLines" xml:"ISPLines"`
-			ISPRegionLines        string `json:"ISPRegionLines" xml:"ISPRegionLines"`
-			OverseaLine           string `json:"OverseaLine" xml:"OverseaLine"`
-			MonitorNodeCount      int64  `json:"MonitorNodeCount" xml:"MonitorNodeCount"`
-			MonitorFrequency      int64  `json:"MonitorFrequency" xml:"MonitorFrequency"`
-			MonitorTaskCount      int64  `json:"MonitorTaskCount" xml:"MonitorTaskCount"`
-			RegionLines           bool   `json:"RegionLines" xml:"RegionLines"`
-			Gslb                  bool   `json:"Gslb" xml:"Gslb"`
-			InClean               bool   `json:"InClean" xml:"InClean"`
-			InBlackHole           bool   `json:"InBlackHole" xml:"InBlackHole"`
-		} `json:"DnsProduct" xml:"DnsProduct"`
-	} `json:"DnsProducts" xml:"DnsProducts"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
+            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
+            PageSize     int64 `json:"PageSize" xml:"PageSize"`
+                DnsProducts struct {
+                    DnsProduct []struct {
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            VersionCode     string `json:"VersionCode" xml:"VersionCode"`
+            VersionName     string `json:"VersionName" xml:"VersionName"`
+            StartTime     string `json:"StartTime" xml:"StartTime"`
+            EndTime     string `json:"EndTime" xml:"EndTime"`
+            StartTimestamp     int64 `json:"StartTimestamp" xml:"StartTimestamp"`
+            EndTimestamp     int64 `json:"EndTimestamp" xml:"EndTimestamp"`
+            Domain     string `json:"Domain" xml:"Domain"`
+            BindCount     int64 `json:"BindCount" xml:"BindCount"`
+            BindUsedCount     int64 `json:"BindUsedCount" xml:"BindUsedCount"`
+            TTLMinValue     int64 `json:"TTLMinValue" xml:"TTLMinValue"`
+            SubDomainLevel     int64 `json:"SubDomainLevel" xml:"SubDomainLevel"`
+            DnsSLBCount     int64 `json:"DnsSLBCount" xml:"DnsSLBCount"`
+            URLForwardCount     int64 `json:"URLForwardCount" xml:"URLForwardCount"`
+            DDosDefendFlow     int64 `json:"DDosDefendFlow" xml:"DDosDefendFlow"`
+            DDosDefendQuery     int64 `json:"DDosDefendQuery" xml:"DDosDefendQuery"`
+            OverseaDDosDefendFlow     int64 `json:"OverseaDDosDefendFlow" xml:"OverseaDDosDefendFlow"`
+            SearchEngineLines     string `json:"SearchEngineLines" xml:"SearchEngineLines"`
+            ISPLines     string `json:"ISPLines" xml:"ISPLines"`
+            ISPRegionLines     string `json:"ISPRegionLines" xml:"ISPRegionLines"`
+            OverseaLine     string `json:"OverseaLine" xml:"OverseaLine"`
+            MonitorNodeCount     int64 `json:"MonitorNodeCount" xml:"MonitorNodeCount"`
+            MonitorFrequency     int64 `json:"MonitorFrequency" xml:"MonitorFrequency"`
+            MonitorTaskCount     int64 `json:"MonitorTaskCount" xml:"MonitorTaskCount"`
+            RegionLines     bool `json:"RegionLines" xml:"RegionLines"`
+            Gslb     bool `json:"Gslb" xml:"Gslb"`
+            InClean     bool `json:"InClean" xml:"InClean"`
+            InBlackHole     bool `json:"InBlackHole" xml:"InBlackHole"`
+                    }   `json:"DnsProduct" xml:"DnsProduct"`
+                } `json:"DnsProducts" xml:"DnsProducts"`
 }
 
 func CreateDescribeDnsProductInstancesRequest() (request *DescribeDnsProductInstancesRequest) {
-	request = &DescribeDnsProductInstancesRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDnsProductInstances", "", "")
-	return
+request = &DescribeDnsProductInstancesRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDnsProductInstances", "", "")
+return
 }
 
 func CreateDescribeDnsProductInstancesResponse() (response *DescribeDnsProductInstancesResponse) {
-	response = &DescribeDnsProductInstancesResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeDnsProductInstancesResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/describe_domain_groups.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,87 +17,89 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainGroups(request *DescribeDomainGroupsRequest) (response *DescribeDomainGroupsResponse, err error) {
-	response = CreateDescribeDomainGroupsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeDomainGroupsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeDomainGroupsWithChan(request *DescribeDomainGroupsRequest) (<-chan *DescribeDomainGroupsResponse, <-chan error) {
-	responseChan := make(chan *DescribeDomainGroupsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeDomainGroups(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeDomainGroupsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeDomainGroups(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainGroupsWithCallback(request *DescribeDomainGroupsRequest, callback func(response *DescribeDomainGroupsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeDomainGroupsResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeDomainGroups(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeDomainGroupsWithCallback(request *DescribeDomainGroupsRequest, callback func(response *DescribeDomainGroupsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeDomainGroupsResponse
+var err error
+defer close(result)
+response, err = client.DescribeDomainGroups(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeDomainGroupsRequest struct {
-	*requests.RpcRequest
-	PageSize     string `position:"Query" name:"PageSize"`
-	PageNumber   string `position:"Query" name:"PageNumber"`
-	KeyWord      string `position:"Query" name:"KeyWord"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                PageSize  string `position:"Query" name:"PageSize"`
+                PageNumber  string `position:"Query" name:"PageNumber"`
+                KeyWord  string `position:"Query" name:"KeyWord"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DescribeDomainGroupsResponse struct {
-	*responses.BaseResponse
-	RequestId    string `json:"RequestId" xml:"RequestId"`
-	TotalCount   int64  `json:"TotalCount" xml:"TotalCount"`
-	PageNumber   int64  `json:"PageNumber" xml:"PageNumber"`
-	PageSize     int64  `json:"PageSize" xml:"PageSize"`
-	DomainGroups struct {
-		DomainGroup []struct {
-			GroupId     string `json:"GroupId" xml:"GroupId"`
-			GroupName   string `json:"GroupName" xml:"GroupName"`
-			DomainCount int64  `json:"DomainCount" xml:"DomainCount"`
-		} `json:"DomainGroup" xml:"DomainGroup"`
-	} `json:"DomainGroups" xml:"DomainGroups"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
+            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
+            PageSize     int64 `json:"PageSize" xml:"PageSize"`
+                DomainGroups struct {
+                    DomainGroup []struct {
+            GroupId     string `json:"GroupId" xml:"GroupId"`
+            GroupName     string `json:"GroupName" xml:"GroupName"`
+            DomainCount     int64 `json:"DomainCount" xml:"DomainCount"`
+                    }   `json:"DomainGroup" xml:"DomainGroup"`
+                } `json:"DomainGroups" xml:"DomainGroups"`
 }
 
 func CreateDescribeDomainGroupsRequest() (request *DescribeDomainGroupsRequest) {
-	request = &DescribeDomainGroupsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainGroups", "", "")
-	return
+request = &DescribeDomainGroupsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainGroups", "", "")
+return
 }
 
 func CreateDescribeDomainGroupsResponse() (response *DescribeDomainGroupsResponse) {
-	response = &DescribeDomainGroupsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeDomainGroupsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/describe_domain_info.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,104 +17,106 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainInfo(request *DescribeDomainInfoRequest) (response *DescribeDomainInfoResponse, err error) {
-	response = CreateDescribeDomainInfoResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeDomainInfoResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeDomainInfoWithChan(request *DescribeDomainInfoRequest) (<-chan *DescribeDomainInfoResponse, <-chan error) {
-	responseChan := make(chan *DescribeDomainInfoResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeDomainInfo(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeDomainInfoResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeDomainInfo(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainInfoWithCallback(request *DescribeDomainInfoRequest, callback func(response *DescribeDomainInfoResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeDomainInfoResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeDomainInfo(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeDomainInfoWithCallback(request *DescribeDomainInfoRequest, callback func(response *DescribeDomainInfoResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeDomainInfoResponse
+var err error
+defer close(result)
+response, err = client.DescribeDomainInfo(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeDomainInfoRequest struct {
-	*requests.RpcRequest
-	NeedDetailAttributes string `position:"Query" name:"NeedDetailAttributes"`
-	DomainName           string `position:"Query" name:"DomainName"`
-	UserClientIp         string `position:"Query" name:"UserClientIp"`
-	Lang                 string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                NeedDetailAttributes  string `position:"Query" name:"NeedDetailAttributes"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DescribeDomainInfoResponse struct {
-	*responses.BaseResponse
-	RequestId          string `json:"RequestId" xml:"RequestId"`
-	DomainId           string `json:"DomainId" xml:"DomainId"`
-	DomainName         string `json:"DomainName" xml:"DomainName"`
-	PunyCode           string `json:"PunyCode" xml:"PunyCode"`
-	AliDomain          bool   `json:"AliDomain" xml:"AliDomain"`
-	Remark             string `json:"Remark" xml:"Remark"`
-	GroupId            string `json:"GroupId" xml:"GroupId"`
-	GroupName          string `json:"GroupName" xml:"GroupName"`
-	InstanceId         string `json:"InstanceId" xml:"InstanceId"`
-	VersionCode        string `json:"VersionCode" xml:"VersionCode"`
-	VersionName        string `json:"VersionName" xml:"VersionName"`
-	MinTtl             int64  `json:"MinTtl" xml:"MinTtl"`
-	RecordLineTreeJson string `json:"RecordLineTreeJson" xml:"RecordLineTreeJson"`
-	LineType           string `json:"LineType" xml:"LineType"`
-	RegionLines        bool   `json:"RegionLines" xml:"RegionLines"`
-	DnsServers         struct {
-		DnsServer []string `json:"DnsServer" xml:"DnsServer"`
-	} `json:"DnsServers" xml:"DnsServers"`
-	AvailableTtls struct {
-		AvailableTtl []string `json:"AvailableTtl" xml:"AvailableTtl"`
-	} `json:"AvailableTtls" xml:"AvailableTtls"`
-	RecordLines struct {
-		RecordLine []struct {
-			LineCode        string `json:"LineCode" xml:"LineCode"`
-			FatherCode      string `json:"FatherCode" xml:"FatherCode"`
-			LineName        string `json:"LineName" xml:"LineName"`
-			LineDisplayName string `json:"LineDisplayName" xml:"LineDisplayName"`
-		} `json:"RecordLine" xml:"RecordLine"`
-	} `json:"RecordLines" xml:"RecordLines"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            DomainId     string `json:"DomainId" xml:"DomainId"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            PunyCode     string `json:"PunyCode" xml:"PunyCode"`
+            AliDomain     bool `json:"AliDomain" xml:"AliDomain"`
+            Remark     string `json:"Remark" xml:"Remark"`
+            GroupId     string `json:"GroupId" xml:"GroupId"`
+            GroupName     string `json:"GroupName" xml:"GroupName"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            VersionCode     string `json:"VersionCode" xml:"VersionCode"`
+            VersionName     string `json:"VersionName" xml:"VersionName"`
+            MinTtl     int64 `json:"MinTtl" xml:"MinTtl"`
+            RecordLineTreeJson     string `json:"RecordLineTreeJson" xml:"RecordLineTreeJson"`
+            LineType     string `json:"LineType" xml:"LineType"`
+            RegionLines     bool `json:"RegionLines" xml:"RegionLines"`
+                DnsServers struct {
+                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
+                } `json:"DnsServers" xml:"DnsServers"`
+                AvailableTtls struct {
+                AvailableTtl []    string `json:"AvailableTtl" xml:"AvailableTtl"`
+                } `json:"AvailableTtls" xml:"AvailableTtls"`
+                RecordLines struct {
+                    RecordLine []struct {
+            LineCode     string `json:"LineCode" xml:"LineCode"`
+            FatherCode     string `json:"FatherCode" xml:"FatherCode"`
+            LineName     string `json:"LineName" xml:"LineName"`
+            LineDisplayName     string `json:"LineDisplayName" xml:"LineDisplayName"`
+                    }   `json:"RecordLine" xml:"RecordLine"`
+                } `json:"RecordLines" xml:"RecordLines"`
 }
 
 func CreateDescribeDomainInfoRequest() (request *DescribeDomainInfoRequest) {
-	request = &DescribeDomainInfoRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainInfo", "", "")
-	return
+request = &DescribeDomainInfoRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainInfo", "", "")
+return
 }
 
 func CreateDescribeDomainInfoResponse() (response *DescribeDomainInfoResponse) {
-	response = &DescribeDomainInfoResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeDomainInfoResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/describe_domain_logs.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,93 +17,95 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainLogs(request *DescribeDomainLogsRequest) (response *DescribeDomainLogsResponse, err error) {
-	response = CreateDescribeDomainLogsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeDomainLogsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeDomainLogsWithChan(request *DescribeDomainLogsRequest) (<-chan *DescribeDomainLogsResponse, <-chan error) {
-	responseChan := make(chan *DescribeDomainLogsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeDomainLogs(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeDomainLogsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeDomainLogs(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainLogsWithCallback(request *DescribeDomainLogsRequest, callback func(response *DescribeDomainLogsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeDomainLogsResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeDomainLogs(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeDomainLogsWithCallback(request *DescribeDomainLogsRequest, callback func(response *DescribeDomainLogsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeDomainLogsResponse
+var err error
+defer close(result)
+response, err = client.DescribeDomainLogs(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeDomainLogsRequest struct {
-	*requests.RpcRequest
-	PageSize     string `position:"Query" name:"PageSize"`
-	StartDate    string `position:"Query" name:"StartDate"`
-	PageNumber   string `position:"Query" name:"PageNumber"`
-	KeyWord      string `position:"Query" name:"KeyWord"`
-	GroupId      string `position:"Query" name:"GroupId"`
-	EndDate      string `position:"Query" name:"endDate"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                PageSize  string `position:"Query" name:"PageSize"`
+                StartDate  string `position:"Query" name:"StartDate"`
+                PageNumber  string `position:"Query" name:"PageNumber"`
+                KeyWord  string `position:"Query" name:"KeyWord"`
+                GroupId  string `position:"Query" name:"GroupId"`
+                EndDate  string `position:"Query" name:"endDate"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DescribeDomainLogsResponse struct {
-	*responses.BaseResponse
-	RequestId  string `json:"RequestId" xml:"RequestId"`
-	TotalCount int64  `json:"TotalCount" xml:"TotalCount"`
-	PageNumber int64  `json:"PageNumber" xml:"PageNumber"`
-	PageSize   int64  `json:"PageSize" xml:"PageSize"`
-	DomainLogs struct {
-		DomainLog []struct {
-			ActionTime      string `json:"ActionTime" xml:"ActionTime"`
-			ActionTimestamp int64  `json:"ActionTimestamp" xml:"ActionTimestamp"`
-			DomainName      string `json:"DomainName" xml:"DomainName"`
-			Action          string `json:"Action" xml:"Action"`
-			Message         string `json:"Message" xml:"Message"`
-			ClientIp        string `json:"ClientIp" xml:"ClientIp"`
-		} `json:"DomainLog" xml:"DomainLog"`
-	} `json:"DomainLogs" xml:"DomainLogs"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
+            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
+            PageSize     int64 `json:"PageSize" xml:"PageSize"`
+                DomainLogs struct {
+                    DomainLog []struct {
+            ActionTime     string `json:"ActionTime" xml:"ActionTime"`
+            ActionTimestamp     int64 `json:"ActionTimestamp" xml:"ActionTimestamp"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            Action     string `json:"Action" xml:"Action"`
+            Message     string `json:"Message" xml:"Message"`
+            ClientIp     string `json:"ClientIp" xml:"ClientIp"`
+                    }   `json:"DomainLog" xml:"DomainLog"`
+                } `json:"DomainLogs" xml:"DomainLogs"`
 }
 
 func CreateDescribeDomainLogsRequest() (request *DescribeDomainLogsRequest) {
-	request = &DescribeDomainLogsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainLogs", "", "")
-	return
+request = &DescribeDomainLogsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainLogs", "", "")
+return
 }
 
 func CreateDescribeDomainLogsResponse() (response *DescribeDomainLogsResponse) {
-	response = &DescribeDomainLogsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeDomainLogsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/describe_domain_ns.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,83 +17,85 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainNs(request *DescribeDomainNsRequest) (response *DescribeDomainNsResponse, err error) {
-	response = CreateDescribeDomainNsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeDomainNsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeDomainNsWithChan(request *DescribeDomainNsRequest) (<-chan *DescribeDomainNsResponse, <-chan error) {
-	responseChan := make(chan *DescribeDomainNsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeDomainNs(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeDomainNsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeDomainNs(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainNsWithCallback(request *DescribeDomainNsRequest, callback func(response *DescribeDomainNsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeDomainNsResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeDomainNs(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeDomainNsWithCallback(request *DescribeDomainNsRequest, callback func(response *DescribeDomainNsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeDomainNsResponse
+var err error
+defer close(result)
+response, err = client.DescribeDomainNs(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeDomainNsRequest struct {
-	*requests.RpcRequest
-	DomainName   string `position:"Query" name:"DomainName"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DescribeDomainNsResponse struct {
-	*responses.BaseResponse
-	RequestId     string `json:"RequestId" xml:"RequestId"`
-	AllAliDns     bool   `json:"AllAliDns" xml:"AllAliDns"`
-	IncludeAliDns bool   `json:"IncludeAliDns" xml:"IncludeAliDns"`
-	DnsServers    struct {
-		DnsServer []string `json:"DnsServer" xml:"DnsServer"`
-	} `json:"DnsServers" xml:"DnsServers"`
-	ExpectDnsServers struct {
-		ExpectDnsServer []string `json:"ExpectDnsServer" xml:"ExpectDnsServer"`
-	} `json:"ExpectDnsServers" xml:"ExpectDnsServers"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            AllAliDns     bool `json:"AllAliDns" xml:"AllAliDns"`
+            IncludeAliDns     bool `json:"IncludeAliDns" xml:"IncludeAliDns"`
+                DnsServers struct {
+                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
+                } `json:"DnsServers" xml:"DnsServers"`
+                ExpectDnsServers struct {
+                ExpectDnsServer []    string `json:"ExpectDnsServer" xml:"ExpectDnsServer"`
+                } `json:"ExpectDnsServers" xml:"ExpectDnsServers"`
 }
 
 func CreateDescribeDomainNsRequest() (request *DescribeDomainNsRequest) {
-	request = &DescribeDomainNsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainNs", "", "")
-	return
+request = &DescribeDomainNsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainNs", "", "")
+return
 }
 
 func CreateDescribeDomainNsResponse() (response *DescribeDomainNsResponse) {
-	response = &DescribeDomainNsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeDomainNsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/describe_domain_record_info.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,89 +17,91 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainRecordInfo(request *DescribeDomainRecordInfoRequest) (response *DescribeDomainRecordInfoResponse, err error) {
-	response = CreateDescribeDomainRecordInfoResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeDomainRecordInfoResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeDomainRecordInfoWithChan(request *DescribeDomainRecordInfoRequest) (<-chan *DescribeDomainRecordInfoResponse, <-chan error) {
-	responseChan := make(chan *DescribeDomainRecordInfoResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeDomainRecordInfo(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeDomainRecordInfoResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeDomainRecordInfo(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainRecordInfoWithCallback(request *DescribeDomainRecordInfoRequest, callback func(response *DescribeDomainRecordInfoResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeDomainRecordInfoResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeDomainRecordInfo(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeDomainRecordInfoWithCallback(request *DescribeDomainRecordInfoRequest, callback func(response *DescribeDomainRecordInfoResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeDomainRecordInfoResponse
+var err error
+defer close(result)
+response, err = client.DescribeDomainRecordInfo(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeDomainRecordInfoRequest struct {
-	*requests.RpcRequest
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
-	RecordId     string `position:"Query" name:"RecordId"`
+*requests.RpcRequest
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
+                RecordId  string `position:"Query" name:"RecordId"`
 }
 
+
 type DescribeDomainRecordInfoResponse struct {
-	*responses.BaseResponse
-	RequestId  string `json:"RequestId" xml:"RequestId"`
-	DomainId   string `json:"DomainId" xml:"DomainId"`
-	DomainName string `json:"DomainName" xml:"DomainName"`
-	PunyCode   string `json:"PunyCode" xml:"PunyCode"`
-	GroupId    string `json:"GroupId" xml:"GroupId"`
-	GroupName  string `json:"GroupName" xml:"GroupName"`
-	RecordId   string `json:"RecordId" xml:"RecordId"`
-	RR         string `json:"RR" xml:"RR"`
-	Type       string `json:"Type" xml:"Type"`
-	Value      string `json:"Value" xml:"Value"`
-	TTL        int64  `json:"TTL" xml:"TTL"`
-	Priority   int64  `json:"Priority" xml:"Priority"`
-	Line       string `json:"Line" xml:"Line"`
-	Status     string `json:"Status" xml:"Status"`
-	Locked     bool   `json:"Locked" xml:"Locked"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            DomainId     string `json:"DomainId" xml:"DomainId"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            PunyCode     string `json:"PunyCode" xml:"PunyCode"`
+            GroupId     string `json:"GroupId" xml:"GroupId"`
+            GroupName     string `json:"GroupName" xml:"GroupName"`
+            RecordId     string `json:"RecordId" xml:"RecordId"`
+            RR     string `json:"RR" xml:"RR"`
+            Type     string `json:"Type" xml:"Type"`
+            Value     string `json:"Value" xml:"Value"`
+            TTL     int64 `json:"TTL" xml:"TTL"`
+            Priority     int64 `json:"Priority" xml:"Priority"`
+            Line     string `json:"Line" xml:"Line"`
+            Status     string `json:"Status" xml:"Status"`
+            Locked     bool `json:"Locked" xml:"Locked"`
 }
 
 func CreateDescribeDomainRecordInfoRequest() (request *DescribeDomainRecordInfoRequest) {
-	request = &DescribeDomainRecordInfoRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainRecordInfo", "", "")
-	return
+request = &DescribeDomainRecordInfoRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainRecordInfo", "", "")
+return
 }
 
 func CreateDescribeDomainRecordInfoResponse() (response *DescribeDomainRecordInfoResponse) {
-	response = &DescribeDomainRecordInfoResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeDomainRecordInfoResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/describe_domain_records.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,100 +17,104 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainRecords(request *DescribeDomainRecordsRequest) (response *DescribeDomainRecordsResponse, err error) {
-	response = CreateDescribeDomainRecordsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeDomainRecordsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeDomainRecordsWithChan(request *DescribeDomainRecordsRequest) (<-chan *DescribeDomainRecordsResponse, <-chan error) {
-	responseChan := make(chan *DescribeDomainRecordsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeDomainRecords(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeDomainRecordsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeDomainRecords(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainRecordsWithCallback(request *DescribeDomainRecordsRequest, callback func(response *DescribeDomainRecordsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeDomainRecordsResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeDomainRecords(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeDomainRecordsWithCallback(request *DescribeDomainRecordsRequest, callback func(response *DescribeDomainRecordsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeDomainRecordsResponse
+var err error
+defer close(result)
+response, err = client.DescribeDomainRecords(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeDomainRecordsRequest struct {
-	*requests.RpcRequest
-	PageSize     string `position:"Query" name:"PageSize"`
-	DomainName   string `position:"Query" name:"DomainName"`
-	ValueKeyWord string `position:"Query" name:"ValueKeyWord"`
-	PageNumber   string `position:"Query" name:"PageNumber"`
-	KeyWord      string `position:"Query" name:"KeyWord"`
-	TypeKeyWord  string `position:"Query" name:"TypeKeyWord"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
-	RRKeyWord    string `position:"Query" name:"RRKeyWord"`
+*requests.RpcRequest
+                PageSize  string `position:"Query" name:"PageSize"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                ValueKeyWord  string `position:"Query" name:"ValueKeyWord"`
+                PageNumber  string `position:"Query" name:"PageNumber"`
+                Direction  string `position:"Query" name:"Direction"`
+                KeyWord  string `position:"Query" name:"KeyWord"`
+                OrderBy  string `position:"Query" name:"OrderBy"`
+                TypeKeyWord  string `position:"Query" name:"TypeKeyWord"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
+                RRKeyWord  string `position:"Query" name:"RRKeyWord"`
 }
 
+
 type DescribeDomainRecordsResponse struct {
-	*responses.BaseResponse
-	RequestId     string `json:"RequestId" xml:"RequestId"`
-	TotalCount    int64  `json:"TotalCount" xml:"TotalCount"`
-	PageNumber    int64  `json:"PageNumber" xml:"PageNumber"`
-	PageSize      int64  `json:"PageSize" xml:"PageSize"`
-	DomainRecords struct {
-		Record []struct {
-			DomainName string `json:"DomainName" xml:"DomainName"`
-			RecordId   string `json:"RecordId" xml:"RecordId"`
-			RR         string `json:"RR" xml:"RR"`
-			Type       string `json:"Type" xml:"Type"`
-			Value      string `json:"Value" xml:"Value"`
-			TTL        int64  `json:"TTL" xml:"TTL"`
-			Priority   int64  `json:"Priority" xml:"Priority"`
-			Line       string `json:"Line" xml:"Line"`
-			Status     string `json:"Status" xml:"Status"`
-			Locked     bool   `json:"Locked" xml:"Locked"`
-			Weight     int    `json:"Weight" xml:"Weight"`
-			Remark     string `json:"Remark" xml:"Remark"`
-		} `json:"Record" xml:"Record"`
-	} `json:"DomainRecords" xml:"DomainRecords"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
+            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
+            PageSize     int64 `json:"PageSize" xml:"PageSize"`
+                DomainRecords struct {
+                    Record []struct {
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            RecordId     string `json:"RecordId" xml:"RecordId"`
+            RR     string `json:"RR" xml:"RR"`
+            Type     string `json:"Type" xml:"Type"`
+            Value     string `json:"Value" xml:"Value"`
+            TTL     int64 `json:"TTL" xml:"TTL"`
+            Priority     int64 `json:"Priority" xml:"Priority"`
+            Line     string `json:"Line" xml:"Line"`
+            Status     string `json:"Status" xml:"Status"`
+            Locked     bool `json:"Locked" xml:"Locked"`
+            Weight     int `json:"Weight" xml:"Weight"`
+            Remark     string `json:"Remark" xml:"Remark"`
+                    }   `json:"Record" xml:"Record"`
+                } `json:"DomainRecords" xml:"DomainRecords"`
 }
 
 func CreateDescribeDomainRecordsRequest() (request *DescribeDomainRecordsRequest) {
-	request = &DescribeDomainRecordsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainRecords", "", "")
-	return
+request = &DescribeDomainRecordsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainRecords", "", "")
+return
 }
 
 func CreateDescribeDomainRecordsResponse() (response *DescribeDomainRecordsResponse) {
-	response = &DescribeDomainRecordsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeDomainRecordsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/describe_domain_whois_info.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,87 +17,89 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainWhoisInfo(request *DescribeDomainWhoisInfoRequest) (response *DescribeDomainWhoisInfoResponse, err error) {
-	response = CreateDescribeDomainWhoisInfoResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeDomainWhoisInfoResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeDomainWhoisInfoWithChan(request *DescribeDomainWhoisInfoRequest) (<-chan *DescribeDomainWhoisInfoResponse, <-chan error) {
-	responseChan := make(chan *DescribeDomainWhoisInfoResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeDomainWhoisInfo(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeDomainWhoisInfoResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeDomainWhoisInfo(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainWhoisInfoWithCallback(request *DescribeDomainWhoisInfoRequest, callback func(response *DescribeDomainWhoisInfoResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeDomainWhoisInfoResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeDomainWhoisInfo(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeDomainWhoisInfoWithCallback(request *DescribeDomainWhoisInfoRequest, callback func(response *DescribeDomainWhoisInfoResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeDomainWhoisInfoResponse
+var err error
+defer close(result)
+response, err = client.DescribeDomainWhoisInfo(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeDomainWhoisInfoRequest struct {
-	*requests.RpcRequest
-	DomainName   string `position:"Query" name:"DomainName"`
-	GroupId      string `position:"Query" name:"GroupId"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                GroupId  string `position:"Query" name:"GroupId"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DescribeDomainWhoisInfoResponse struct {
-	*responses.BaseResponse
-	RequestId        string `json:"RequestId" xml:"RequestId"`
-	RegistrantName   string `json:"RegistrantName" xml:"RegistrantName"`
-	RegistrantEmail  string `json:"RegistrantEmail" xml:"RegistrantEmail"`
-	Registrar        string `json:"Registrar" xml:"Registrar"`
-	RegistrationDate string `json:"RegistrationDate" xml:"RegistrationDate"`
-	ExpirationDate   string `json:"ExpirationDate" xml:"ExpirationDate"`
-	StatusList       struct {
-		Status []string `json:"Status" xml:"Status"`
-	} `json:"StatusList" xml:"StatusList"`
-	DnsServers struct {
-		DnsServer []string `json:"DnsServer" xml:"DnsServer"`
-	} `json:"DnsServers" xml:"DnsServers"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            RegistrantName     string `json:"RegistrantName" xml:"RegistrantName"`
+            RegistrantEmail     string `json:"RegistrantEmail" xml:"RegistrantEmail"`
+            Registrar     string `json:"Registrar" xml:"Registrar"`
+            RegistrationDate     string `json:"RegistrationDate" xml:"RegistrationDate"`
+            ExpirationDate     string `json:"ExpirationDate" xml:"ExpirationDate"`
+                StatusList struct {
+                Status []    string `json:"Status" xml:"Status"`
+                } `json:"StatusList" xml:"StatusList"`
+                DnsServers struct {
+                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
+                } `json:"DnsServers" xml:"DnsServers"`
 }
 
 func CreateDescribeDomainWhoisInfoRequest() (request *DescribeDomainWhoisInfoRequest) {
-	request = &DescribeDomainWhoisInfoRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainWhoisInfo", "", "")
-	return
+request = &DescribeDomainWhoisInfoRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainWhoisInfo", "", "")
+return
 }
 
 func CreateDescribeDomainWhoisInfoResponse() (response *DescribeDomainWhoisInfoResponse) {
-	response = &DescribeDomainWhoisInfoResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeDomainWhoisInfoResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/describe_domains.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,102 +17,104 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomains(request *DescribeDomainsRequest) (response *DescribeDomainsResponse, err error) {
-	response = CreateDescribeDomainsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeDomainsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeDomainsWithChan(request *DescribeDomainsRequest) (<-chan *DescribeDomainsResponse, <-chan error) {
-	responseChan := make(chan *DescribeDomainsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeDomains(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeDomainsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeDomains(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainsWithCallback(request *DescribeDomainsRequest, callback func(response *DescribeDomainsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeDomainsResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeDomains(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeDomainsWithCallback(request *DescribeDomainsRequest, callback func(response *DescribeDomainsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeDomainsResponse
+var err error
+defer close(result)
+response, err = client.DescribeDomains(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeDomainsRequest struct {
-	*requests.RpcRequest
-	PageSize     string `position:"Query" name:"PageSize"`
-	PageNumber   string `position:"Query" name:"PageNumber"`
-	KeyWord      string `position:"Query" name:"KeyWord"`
-	GroupId      string `position:"Query" name:"GroupId"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                PageSize  string `position:"Query" name:"PageSize"`
+                PageNumber  string `position:"Query" name:"PageNumber"`
+                KeyWord  string `position:"Query" name:"KeyWord"`
+                GroupId  string `position:"Query" name:"GroupId"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DescribeDomainsResponse struct {
-	*responses.BaseResponse
-	RequestId  string `json:"RequestId" xml:"RequestId"`
-	TotalCount int64  `json:"TotalCount" xml:"TotalCount"`
-	PageNumber int64  `json:"PageNumber" xml:"PageNumber"`
-	PageSize   int64  `json:"PageSize" xml:"PageSize"`
-	Domains    struct {
-		Domain []struct {
-			DomainId        string `json:"DomainId" xml:"DomainId"`
-			DomainName      string `json:"DomainName" xml:"DomainName"`
-			PunyCode        string `json:"PunyCode" xml:"PunyCode"`
-			AliDomain       bool   `json:"AliDomain" xml:"AliDomain"`
-			RecordCount     int64  `json:"RecordCount" xml:"RecordCount"`
-			RegistrantEmail string `json:"RegistrantEmail" xml:"RegistrantEmail"`
-			Remark          string `json:"Remark" xml:"Remark"`
-			GroupId         string `json:"GroupId" xml:"GroupId"`
-			GroupName       string `json:"GroupName" xml:"GroupName"`
-			InstanceId      string `json:"InstanceId" xml:"InstanceId"`
-			VersionCode     string `json:"VersionCode" xml:"VersionCode"`
-			VersionName     string `json:"VersionName" xml:"VersionName"`
-			InstanceEndTime string `json:"InstanceEndTime" xml:"InstanceEndTime"`
-			InstanceExpired bool   `json:"InstanceExpired" xml:"InstanceExpired"`
-			DnsServers      struct {
-				DnsServer []string `json:"DnsServer" xml:"DnsServer"`
-			} `json:"DnsServers" xml:"DnsServers"`
-		} `json:"Domain" xml:"Domain"`
-	} `json:"Domains" xml:"Domains"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
+            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
+            PageSize     int64 `json:"PageSize" xml:"PageSize"`
+                Domains struct {
+                    Domain []struct {
+            DomainId     string `json:"DomainId" xml:"DomainId"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            PunyCode     string `json:"PunyCode" xml:"PunyCode"`
+            AliDomain     bool `json:"AliDomain" xml:"AliDomain"`
+            RecordCount     int64 `json:"RecordCount" xml:"RecordCount"`
+            RegistrantEmail     string `json:"RegistrantEmail" xml:"RegistrantEmail"`
+            Remark     string `json:"Remark" xml:"Remark"`
+            GroupId     string `json:"GroupId" xml:"GroupId"`
+            GroupName     string `json:"GroupName" xml:"GroupName"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            VersionCode     string `json:"VersionCode" xml:"VersionCode"`
+            VersionName     string `json:"VersionName" xml:"VersionName"`
+            InstanceEndTime     string `json:"InstanceEndTime" xml:"InstanceEndTime"`
+            InstanceExpired     bool `json:"InstanceExpired" xml:"InstanceExpired"`
+                DnsServers struct {
+                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
+                } `json:"DnsServers" xml:"DnsServers"`
+                    }   `json:"Domain" xml:"Domain"`
+                } `json:"Domains" xml:"Domains"`
 }
 
 func CreateDescribeDomainsRequest() (request *DescribeDomainsRequest) {
-	request = &DescribeDomainsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomains", "", "")
-	return
+request = &DescribeDomainsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomains", "", "")
+return
 }
 
 func CreateDescribeDomainsResponse() (response *DescribeDomainsResponse) {
-	response = &DescribeDomainsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeDomainsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/describe_record_logs.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,92 +17,94 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeRecordLogs(request *DescribeRecordLogsRequest) (response *DescribeRecordLogsResponse, err error) {
-	response = CreateDescribeRecordLogsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeRecordLogsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeRecordLogsWithChan(request *DescribeRecordLogsRequest) (<-chan *DescribeRecordLogsResponse, <-chan error) {
-	responseChan := make(chan *DescribeRecordLogsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeRecordLogs(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeRecordLogsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeRecordLogs(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeRecordLogsWithCallback(request *DescribeRecordLogsRequest, callback func(response *DescribeRecordLogsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeRecordLogsResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeRecordLogs(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeRecordLogsWithCallback(request *DescribeRecordLogsRequest, callback func(response *DescribeRecordLogsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeRecordLogsResponse
+var err error
+defer close(result)
+response, err = client.DescribeRecordLogs(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeRecordLogsRequest struct {
-	*requests.RpcRequest
-	PageSize     string `position:"Query" name:"PageSize"`
-	StartDate    string `position:"Query" name:"StartDate"`
-	DomainName   string `position:"Query" name:"DomainName"`
-	PageNumber   string `position:"Query" name:"PageNumber"`
-	KeyWord      string `position:"Query" name:"KeyWord"`
-	EndDate      string `position:"Query" name:"endDate"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                PageSize  string `position:"Query" name:"PageSize"`
+                StartDate  string `position:"Query" name:"StartDate"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                PageNumber  string `position:"Query" name:"PageNumber"`
+                KeyWord  string `position:"Query" name:"KeyWord"`
+                EndDate  string `position:"Query" name:"endDate"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DescribeRecordLogsResponse struct {
-	*responses.BaseResponse
-	RequestId  string `json:"RequestId" xml:"RequestId"`
-	TotalCount int64  `json:"TotalCount" xml:"TotalCount"`
-	PageNumber int64  `json:"PageNumber" xml:"PageNumber"`
-	PageSize   int64  `json:"PageSize" xml:"PageSize"`
-	RecordLogs struct {
-		RecordLog []struct {
-			ActionTime      string `json:"ActionTime" xml:"ActionTime"`
-			ActionTimestamp int64  `json:"ActionTimestamp" xml:"ActionTimestamp"`
-			Action          string `json:"Action" xml:"Action"`
-			Message         string `json:"Message" xml:"Message"`
-			ClientIp        string `json:"ClientIp" xml:"ClientIp"`
-		} `json:"RecordLog" xml:"RecordLog"`
-	} `json:"RecordLogs" xml:"RecordLogs"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
+            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
+            PageSize     int64 `json:"PageSize" xml:"PageSize"`
+                RecordLogs struct {
+                    RecordLog []struct {
+            ActionTime     string `json:"ActionTime" xml:"ActionTime"`
+            ActionTimestamp     int64 `json:"ActionTimestamp" xml:"ActionTimestamp"`
+            Action     string `json:"Action" xml:"Action"`
+            Message     string `json:"Message" xml:"Message"`
+            ClientIp     string `json:"ClientIp" xml:"ClientIp"`
+                    }   `json:"RecordLog" xml:"RecordLog"`
+                } `json:"RecordLogs" xml:"RecordLogs"`
 }
 
 func CreateDescribeRecordLogsRequest() (request *DescribeRecordLogsRequest) {
-	request = &DescribeRecordLogsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeRecordLogs", "", "")
-	return
+request = &DescribeRecordLogsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeRecordLogs", "", "")
+return
 }
 
 func CreateDescribeRecordLogsResponse() (response *DescribeRecordLogsResponse) {
-	response = &DescribeRecordLogsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeRecordLogsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/describe_sub_domain_records.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,96 +17,98 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeSubDomainRecords(request *DescribeSubDomainRecordsRequest) (response *DescribeSubDomainRecordsResponse, err error) {
-	response = CreateDescribeSubDomainRecordsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeSubDomainRecordsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeSubDomainRecordsWithChan(request *DescribeSubDomainRecordsRequest) (<-chan *DescribeSubDomainRecordsResponse, <-chan error) {
-	responseChan := make(chan *DescribeSubDomainRecordsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeSubDomainRecords(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeSubDomainRecordsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeSubDomainRecords(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeSubDomainRecordsWithCallback(request *DescribeSubDomainRecordsRequest, callback func(response *DescribeSubDomainRecordsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeSubDomainRecordsResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeSubDomainRecords(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeSubDomainRecordsWithCallback(request *DescribeSubDomainRecordsRequest, callback func(response *DescribeSubDomainRecordsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeSubDomainRecordsResponse
+var err error
+defer close(result)
+response, err = client.DescribeSubDomainRecords(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeSubDomainRecordsRequest struct {
-	*requests.RpcRequest
-	PageSize     string `position:"Query" name:"PageSize"`
-	PageNumber   string `position:"Query" name:"PageNumber"`
-	SubDomain    string `position:"Query" name:"SubDomain"`
-	Type         string `position:"Query" name:"Type"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                PageSize  string `position:"Query" name:"PageSize"`
+                PageNumber  string `position:"Query" name:"PageNumber"`
+                SubDomain  string `position:"Query" name:"SubDomain"`
+                Type  string `position:"Query" name:"Type"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DescribeSubDomainRecordsResponse struct {
-	*responses.BaseResponse
-	RequestId     string `json:"RequestId" xml:"RequestId"`
-	TotalCount    int64  `json:"TotalCount" xml:"TotalCount"`
-	PageNumber    int64  `json:"PageNumber" xml:"PageNumber"`
-	PageSize      int64  `json:"PageSize" xml:"PageSize"`
-	DomainRecords struct {
-		Record []struct {
-			DomainName string `json:"DomainName" xml:"DomainName"`
-			RecordId   string `json:"RecordId" xml:"RecordId"`
-			RR         string `json:"RR" xml:"RR"`
-			Type       string `json:"Type" xml:"Type"`
-			Value      string `json:"Value" xml:"Value"`
-			TTL        int64  `json:"TTL" xml:"TTL"`
-			Priority   int64  `json:"Priority" xml:"Priority"`
-			Line       string `json:"Line" xml:"Line"`
-			Status     string `json:"Status" xml:"Status"`
-			Locked     bool   `json:"Locked" xml:"Locked"`
-			Weight     int    `json:"Weight" xml:"Weight"`
-		} `json:"Record" xml:"Record"`
-	} `json:"DomainRecords" xml:"DomainRecords"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
+            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
+            PageSize     int64 `json:"PageSize" xml:"PageSize"`
+                DomainRecords struct {
+                    Record []struct {
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            RecordId     string `json:"RecordId" xml:"RecordId"`
+            RR     string `json:"RR" xml:"RR"`
+            Type     string `json:"Type" xml:"Type"`
+            Value     string `json:"Value" xml:"Value"`
+            TTL     int64 `json:"TTL" xml:"TTL"`
+            Priority     int64 `json:"Priority" xml:"Priority"`
+            Line     string `json:"Line" xml:"Line"`
+            Status     string `json:"Status" xml:"Status"`
+            Locked     bool `json:"Locked" xml:"Locked"`
+            Weight     int `json:"Weight" xml:"Weight"`
+                    }   `json:"Record" xml:"Record"`
+                } `json:"DomainRecords" xml:"DomainRecords"`
 }
 
 func CreateDescribeSubDomainRecordsRequest() (request *DescribeSubDomainRecordsRequest) {
-	request = &DescribeSubDomainRecordsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeSubDomainRecords", "", "")
-	return
+request = &DescribeSubDomainRecordsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeSubDomainRecords", "", "")
+return
 }
 
 func CreateDescribeSubDomainRecordsResponse() (response *DescribeSubDomainRecordsResponse) {
-	response = &DescribeSubDomainRecordsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeSubDomainRecordsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/describe_support_lines.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,82 +17,84 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeSupportLines(request *DescribeSupportLinesRequest) (response *DescribeSupportLinesResponse, err error) {
-	response = CreateDescribeSupportLinesResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeSupportLinesResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeSupportLinesWithChan(request *DescribeSupportLinesRequest) (<-chan *DescribeSupportLinesResponse, <-chan error) {
-	responseChan := make(chan *DescribeSupportLinesResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeSupportLines(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeSupportLinesResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeSupportLines(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeSupportLinesWithCallback(request *DescribeSupportLinesRequest, callback func(response *DescribeSupportLinesResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeSupportLinesResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeSupportLines(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeSupportLinesWithCallback(request *DescribeSupportLinesRequest, callback func(response *DescribeSupportLinesResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeSupportLinesResponse
+var err error
+defer close(result)
+response, err = client.DescribeSupportLines(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeSupportLinesRequest struct {
-	*requests.RpcRequest
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type DescribeSupportLinesResponse struct {
-	*responses.BaseResponse
-	RequestId   string `json:"RequestId" xml:"RequestId"`
-	RecordLines struct {
-		RecordLine []struct {
-			LineCode        string `json:"LineCode" xml:"LineCode"`
-			FatherCode      string `json:"FatherCode" xml:"FatherCode"`
-			LineName        string `json:"LineName" xml:"LineName"`
-			LineDisplayName string `json:"LineDisplayName" xml:"LineDisplayName"`
-		} `json:"RecordLine" xml:"RecordLine"`
-	} `json:"RecordLines" xml:"RecordLines"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+                RecordLines struct {
+                    RecordLine []struct {
+            LineCode     string `json:"LineCode" xml:"LineCode"`
+            FatherCode     string `json:"FatherCode" xml:"FatherCode"`
+            LineName     string `json:"LineName" xml:"LineName"`
+            LineDisplayName     string `json:"LineDisplayName" xml:"LineDisplayName"`
+                    }   `json:"RecordLine" xml:"RecordLine"`
+                } `json:"RecordLines" xml:"RecordLines"`
 }
 
 func CreateDescribeSupportLinesRequest() (request *DescribeSupportLinesRequest) {
-	request = &DescribeSupportLinesRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeSupportLines", "", "")
-	return
+request = &DescribeSupportLinesRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeSupportLines", "", "")
+return
 }
 
 func CreateDescribeSupportLinesResponse() (response *DescribeSupportLinesResponse) {
-	response = &DescribeSupportLinesResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeSupportLinesResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/get_main_domain_name.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,78 +17,80 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) GetMainDomainName(request *GetMainDomainNameRequest) (response *GetMainDomainNameResponse, err error) {
-	response = CreateGetMainDomainNameResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateGetMainDomainNameResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) GetMainDomainNameWithChan(request *GetMainDomainNameRequest) (<-chan *GetMainDomainNameResponse, <-chan error) {
-	responseChan := make(chan *GetMainDomainNameResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.GetMainDomainName(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *GetMainDomainNameResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.GetMainDomainName(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) GetMainDomainNameWithCallback(request *GetMainDomainNameRequest, callback func(response *GetMainDomainNameResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *GetMainDomainNameResponse
-		var err error
-		defer close(result)
-		response, err = client.GetMainDomainName(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) GetMainDomainNameWithCallback(request *GetMainDomainNameRequest, callback func(response *GetMainDomainNameResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *GetMainDomainNameResponse
+var err error
+defer close(result)
+response, err = client.GetMainDomainName(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type GetMainDomainNameRequest struct {
-	*requests.RpcRequest
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	InputString  string `position:"Query" name:"InputString"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                InputString  string `position:"Query" name:"InputString"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type GetMainDomainNameResponse struct {
-	*responses.BaseResponse
-	RequestId   string `json:"RequestId" xml:"RequestId"`
-	DomainName  string `json:"DomainName" xml:"DomainName"`
-	RR          string `json:"RR" xml:"RR"`
-	DomainLevel int64  `json:"DomainLevel" xml:"DomainLevel"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            RR     string `json:"RR" xml:"RR"`
+            DomainLevel     int64 `json:"DomainLevel" xml:"DomainLevel"`
 }
 
 func CreateGetMainDomainNameRequest() (request *GetMainDomainNameRequest) {
-	request = &GetMainDomainNameRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "GetMainDomainName", "", "")
-	return
+request = &GetMainDomainNameRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "GetMainDomainName", "", "")
+return
 }
 
 func CreateGetMainDomainNameResponse() (response *GetMainDomainNameResponse) {
-	response = &GetMainDomainNameResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &GetMainDomainNameResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/modify_hichina_domain_d_n_s.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,81 +17,83 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ModifyHichinaDomainDNS(request *ModifyHichinaDomainDNSRequest) (response *ModifyHichinaDomainDNSResponse, err error) {
-	response = CreateModifyHichinaDomainDNSResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateModifyHichinaDomainDNSResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ModifyHichinaDomainDNSWithChan(request *ModifyHichinaDomainDNSRequest) (<-chan *ModifyHichinaDomainDNSResponse, <-chan error) {
-	responseChan := make(chan *ModifyHichinaDomainDNSResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ModifyHichinaDomainDNS(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ModifyHichinaDomainDNSResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ModifyHichinaDomainDNS(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ModifyHichinaDomainDNSWithCallback(request *ModifyHichinaDomainDNSRequest, callback func(response *ModifyHichinaDomainDNSResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ModifyHichinaDomainDNSResponse
-		var err error
-		defer close(result)
-		response, err = client.ModifyHichinaDomainDNS(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ModifyHichinaDomainDNSWithCallback(request *ModifyHichinaDomainDNSRequest, callback func(response *ModifyHichinaDomainDNSResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ModifyHichinaDomainDNSResponse
+var err error
+defer close(result)
+response, err = client.ModifyHichinaDomainDNS(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ModifyHichinaDomainDNSRequest struct {
-	*requests.RpcRequest
-	DomainName   string `position:"Query" name:"DomainName"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type ModifyHichinaDomainDNSResponse struct {
-	*responses.BaseResponse
-	RequestId          string `json:"RequestId" xml:"RequestId"`
-	OriginalDnsServers struct {
-		DnsServer []string `json:"DnsServer" xml:"DnsServer"`
-	} `json:"OriginalDnsServers" xml:"OriginalDnsServers"`
-	NewDnsServers struct {
-		DnsServer []string `json:"DnsServer" xml:"DnsServer"`
-	} `json:"NewDnsServers" xml:"NewDnsServers"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+                OriginalDnsServers struct {
+                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
+                } `json:"OriginalDnsServers" xml:"OriginalDnsServers"`
+                NewDnsServers struct {
+                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
+                } `json:"NewDnsServers" xml:"NewDnsServers"`
 }
 
 func CreateModifyHichinaDomainDNSRequest() (request *ModifyHichinaDomainDNSRequest) {
-	request = &ModifyHichinaDomainDNSRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "ModifyHichinaDomainDNS", "", "")
-	return
+request = &ModifyHichinaDomainDNSRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "ModifyHichinaDomainDNS", "", "")
+return
 }
 
 func CreateModifyHichinaDomainDNSResponse() (response *ModifyHichinaDomainDNSResponse) {
-	response = &ModifyHichinaDomainDNSResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ModifyHichinaDomainDNSResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/retrieval_domain_name.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,77 +17,79 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) RetrievalDomainName(request *RetrievalDomainNameRequest) (response *RetrievalDomainNameResponse, err error) {
-	response = CreateRetrievalDomainNameResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateRetrievalDomainNameResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) RetrievalDomainNameWithChan(request *RetrievalDomainNameRequest) (<-chan *RetrievalDomainNameResponse, <-chan error) {
-	responseChan := make(chan *RetrievalDomainNameResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.RetrievalDomainName(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *RetrievalDomainNameResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.RetrievalDomainName(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) RetrievalDomainNameWithCallback(request *RetrievalDomainNameRequest, callback func(response *RetrievalDomainNameResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *RetrievalDomainNameResponse
-		var err error
-		defer close(result)
-		response, err = client.RetrievalDomainName(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) RetrievalDomainNameWithCallback(request *RetrievalDomainNameRequest, callback func(response *RetrievalDomainNameResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *RetrievalDomainNameResponse
+var err error
+defer close(result)
+response, err = client.RetrievalDomainName(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type RetrievalDomainNameRequest struct {
-	*requests.RpcRequest
-	DomainName   string `position:"Query" name:"DomainName"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type RetrievalDomainNameResponse struct {
-	*responses.BaseResponse
-	RequestId  string `json:"RequestId" xml:"RequestId"`
-	DomainName string `json:"DomainName" xml:"DomainName"`
-	WhoisEmail string `json:"WhoisEmail" xml:"WhoisEmail"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            WhoisEmail     string `json:"WhoisEmail" xml:"WhoisEmail"`
 }
 
 func CreateRetrievalDomainNameRequest() (request *RetrievalDomainNameRequest) {
-	request = &RetrievalDomainNameRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "RetrievalDomainName", "", "")
-	return
+request = &RetrievalDomainNameRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "RetrievalDomainName", "", "")
+return
 }
 
 func CreateRetrievalDomainNameResponse() (response *RetrievalDomainNameResponse) {
-	response = &RetrievalDomainNameResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &RetrievalDomainNameResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/set_d_n_s_s_l_b_status.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,78 +17,80 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) SetDNSSLBStatus(request *SetDNSSLBStatusRequest) (response *SetDNSSLBStatusResponse, err error) {
-	response = CreateSetDNSSLBStatusResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateSetDNSSLBStatusResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) SetDNSSLBStatusWithChan(request *SetDNSSLBStatusRequest) (<-chan *SetDNSSLBStatusResponse, <-chan error) {
-	responseChan := make(chan *SetDNSSLBStatusResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.SetDNSSLBStatus(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *SetDNSSLBStatusResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.SetDNSSLBStatus(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) SetDNSSLBStatusWithCallback(request *SetDNSSLBStatusRequest, callback func(response *SetDNSSLBStatusResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *SetDNSSLBStatusResponse
-		var err error
-		defer close(result)
-		response, err = client.SetDNSSLBStatus(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) SetDNSSLBStatusWithCallback(request *SetDNSSLBStatusRequest, callback func(response *SetDNSSLBStatusResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *SetDNSSLBStatusResponse
+var err error
+defer close(result)
+response, err = client.SetDNSSLBStatus(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type SetDNSSLBStatusRequest struct {
-	*requests.RpcRequest
-	Open         string `position:"Query" name:"Open"`
-	SubDomain    string `position:"Query" name:"SubDomain"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                Open  string `position:"Query" name:"Open"`
+                SubDomain  string `position:"Query" name:"SubDomain"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type SetDNSSLBStatusResponse struct {
-	*responses.BaseResponse
-	RequestId   string `json:"RequestId" xml:"RequestId"`
-	RecordCount int64  `json:"RecordCount" xml:"RecordCount"`
-	Open        bool   `json:"Open" xml:"Open"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            RecordCount     int64 `json:"RecordCount" xml:"RecordCount"`
+            Open     bool `json:"Open" xml:"Open"`
 }
 
 func CreateSetDNSSLBStatusRequest() (request *SetDNSSLBStatusRequest) {
-	request = &SetDNSSLBStatusRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "SetDNSSLBStatus", "", "")
-	return
+request = &SetDNSSLBStatusRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "SetDNSSLBStatus", "", "")
+return
 }
 
 func CreateSetDNSSLBStatusResponse() (response *SetDNSSLBStatusResponse) {
-	response = &SetDNSSLBStatusResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &SetDNSSLBStatusResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/set_domain_record_status.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,78 +17,80 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) SetDomainRecordStatus(request *SetDomainRecordStatusRequest) (response *SetDomainRecordStatusResponse, err error) {
-	response = CreateSetDomainRecordStatusResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateSetDomainRecordStatusResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) SetDomainRecordStatusWithChan(request *SetDomainRecordStatusRequest) (<-chan *SetDomainRecordStatusResponse, <-chan error) {
-	responseChan := make(chan *SetDomainRecordStatusResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.SetDomainRecordStatus(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *SetDomainRecordStatusResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.SetDomainRecordStatus(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) SetDomainRecordStatusWithCallback(request *SetDomainRecordStatusRequest, callback func(response *SetDomainRecordStatusResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *SetDomainRecordStatusResponse
-		var err error
-		defer close(result)
-		response, err = client.SetDomainRecordStatus(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) SetDomainRecordStatusWithCallback(request *SetDomainRecordStatusRequest, callback func(response *SetDomainRecordStatusResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *SetDomainRecordStatusResponse
+var err error
+defer close(result)
+response, err = client.SetDomainRecordStatus(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type SetDomainRecordStatusRequest struct {
-	*requests.RpcRequest
-	Status       string `position:"Query" name:"Status"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
-	RecordId     string `position:"Query" name:"RecordId"`
+*requests.RpcRequest
+                Status  string `position:"Query" name:"Status"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
+                RecordId  string `position:"Query" name:"RecordId"`
 }
 
+
 type SetDomainRecordStatusResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId" xml:"RequestId"`
-	RecordId  string `json:"RecordId" xml:"RecordId"`
-	Status    string `json:"Status" xml:"Status"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            RecordId     string `json:"RecordId" xml:"RecordId"`
+            Status     string `json:"Status" xml:"Status"`
 }
 
 func CreateSetDomainRecordStatusRequest() (request *SetDomainRecordStatusRequest) {
-	request = &SetDomainRecordStatusRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "SetDomainRecordStatus", "", "")
-	return
+request = &SetDomainRecordStatusRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "SetDomainRecordStatus", "", "")
+return
 }
 
 func CreateSetDomainRecordStatusResponse() (response *SetDomainRecordStatusResponse) {
-	response = &SetDomainRecordStatusResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &SetDomainRecordStatusResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/update_batch_domain_records.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,76 +17,78 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) UpdateBatchDomainRecords(request *UpdateBatchDomainRecordsRequest) (response *UpdateBatchDomainRecordsResponse, err error) {
-	response = CreateUpdateBatchDomainRecordsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateUpdateBatchDomainRecordsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) UpdateBatchDomainRecordsWithChan(request *UpdateBatchDomainRecordsRequest) (<-chan *UpdateBatchDomainRecordsResponse, <-chan error) {
-	responseChan := make(chan *UpdateBatchDomainRecordsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.UpdateBatchDomainRecords(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *UpdateBatchDomainRecordsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.UpdateBatchDomainRecords(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) UpdateBatchDomainRecordsWithCallback(request *UpdateBatchDomainRecordsRequest, callback func(response *UpdateBatchDomainRecordsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *UpdateBatchDomainRecordsResponse
-		var err error
-		defer close(result)
-		response, err = client.UpdateBatchDomainRecords(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) UpdateBatchDomainRecordsWithCallback(request *UpdateBatchDomainRecordsRequest, callback func(response *UpdateBatchDomainRecordsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *UpdateBatchDomainRecordsResponse
+var err error
+defer close(result)
+response, err = client.UpdateBatchDomainRecords(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type UpdateBatchDomainRecordsRequest struct {
-	*requests.RpcRequest
-	Records      string `position:"Query" name:"Records"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                Records  string `position:"Query" name:"Records"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type UpdateBatchDomainRecordsResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId" xml:"RequestId"`
-	TraceId   string `json:"TraceId" xml:"TraceId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            TraceId     string `json:"TraceId" xml:"TraceId"`
 }
 
 func CreateUpdateBatchDomainRecordsRequest() (request *UpdateBatchDomainRecordsRequest) {
-	request = &UpdateBatchDomainRecordsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateBatchDomainRecords", "", "")
-	return
+request = &UpdateBatchDomainRecordsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateBatchDomainRecords", "", "")
+return
 }
 
 func CreateUpdateBatchDomainRecordsResponse() (response *UpdateBatchDomainRecordsResponse) {
-	response = &UpdateBatchDomainRecordsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &UpdateBatchDomainRecordsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/update_d_n_s_s_l_b_weight.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,78 +17,80 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) UpdateDNSSLBWeight(request *UpdateDNSSLBWeightRequest) (response *UpdateDNSSLBWeightResponse, err error) {
-	response = CreateUpdateDNSSLBWeightResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateUpdateDNSSLBWeightResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) UpdateDNSSLBWeightWithChan(request *UpdateDNSSLBWeightRequest) (<-chan *UpdateDNSSLBWeightResponse, <-chan error) {
-	responseChan := make(chan *UpdateDNSSLBWeightResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.UpdateDNSSLBWeight(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *UpdateDNSSLBWeightResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.UpdateDNSSLBWeight(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) UpdateDNSSLBWeightWithCallback(request *UpdateDNSSLBWeightRequest, callback func(response *UpdateDNSSLBWeightResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *UpdateDNSSLBWeightResponse
-		var err error
-		defer close(result)
-		response, err = client.UpdateDNSSLBWeight(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) UpdateDNSSLBWeightWithCallback(request *UpdateDNSSLBWeightRequest, callback func(response *UpdateDNSSLBWeightResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *UpdateDNSSLBWeightResponse
+var err error
+defer close(result)
+response, err = client.UpdateDNSSLBWeight(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type UpdateDNSSLBWeightRequest struct {
-	*requests.RpcRequest
-	Weight       string `position:"Query" name:"Weight"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
-	RecordId     string `position:"Query" name:"RecordId"`
+*requests.RpcRequest
+                Weight  string `position:"Query" name:"Weight"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
+                RecordId  string `position:"Query" name:"RecordId"`
 }
 
+
 type UpdateDNSSLBWeightResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId" xml:"RequestId"`
-	RecordId  string `json:"RecordId" xml:"RecordId"`
-	Weight    int    `json:"Weight" xml:"Weight"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            RecordId     string `json:"RecordId" xml:"RecordId"`
+            Weight     int `json:"Weight" xml:"Weight"`
 }
 
 func CreateUpdateDNSSLBWeightRequest() (request *UpdateDNSSLBWeightRequest) {
-	request = &UpdateDNSSLBWeightRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateDNSSLBWeight", "", "")
-	return
+request = &UpdateDNSSLBWeightRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateDNSSLBWeight", "", "")
+return
 }
 
 func CreateUpdateDNSSLBWeightResponse() (response *UpdateDNSSLBWeightResponse) {
-	response = &UpdateDNSSLBWeightResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &UpdateDNSSLBWeightResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/update_domain_group.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,78 +17,80 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) UpdateDomainGroup(request *UpdateDomainGroupRequest) (response *UpdateDomainGroupResponse, err error) {
-	response = CreateUpdateDomainGroupResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateUpdateDomainGroupResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) UpdateDomainGroupWithChan(request *UpdateDomainGroupRequest) (<-chan *UpdateDomainGroupResponse, <-chan error) {
-	responseChan := make(chan *UpdateDomainGroupResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.UpdateDomainGroup(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *UpdateDomainGroupResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.UpdateDomainGroup(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) UpdateDomainGroupWithCallback(request *UpdateDomainGroupRequest, callback func(response *UpdateDomainGroupResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *UpdateDomainGroupResponse
-		var err error
-		defer close(result)
-		response, err = client.UpdateDomainGroup(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) UpdateDomainGroupWithCallback(request *UpdateDomainGroupRequest, callback func(response *UpdateDomainGroupResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *UpdateDomainGroupResponse
+var err error
+defer close(result)
+response, err = client.UpdateDomainGroup(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type UpdateDomainGroupRequest struct {
-	*requests.RpcRequest
-	GroupName    string `position:"Query" name:"GroupName"`
-	GroupId      string `position:"Query" name:"GroupId"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
+*requests.RpcRequest
+                GroupName  string `position:"Query" name:"GroupName"`
+                GroupId  string `position:"Query" name:"GroupId"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
 }
 
+
 type UpdateDomainGroupResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId" xml:"RequestId"`
-	GroupId   string `json:"GroupId" xml:"GroupId"`
-	GroupName string `json:"GroupName" xml:"GroupName"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            GroupId     string `json:"GroupId" xml:"GroupId"`
+            GroupName     string `json:"GroupName" xml:"GroupName"`
 }
 
 func CreateUpdateDomainGroupRequest() (request *UpdateDomainGroupRequest) {
-	request = &UpdateDomainGroupRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateDomainGroup", "", "")
-	return
+request = &UpdateDomainGroupRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateDomainGroup", "", "")
+return
 }
 
 func CreateUpdateDomainGroupResponse() (response *UpdateDomainGroupResponse) {
-	response = &UpdateDomainGroupResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &UpdateDomainGroupResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/alidns/update_domain_record.go

@@ -1,3 +1,4 @@
+
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,82 +17,84 @@ package alidns
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) UpdateDomainRecord(request *UpdateDomainRecordRequest) (response *UpdateDomainRecordResponse, err error) {
-	response = CreateUpdateDomainRecordResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateUpdateDomainRecordResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) UpdateDomainRecordWithChan(request *UpdateDomainRecordRequest) (<-chan *UpdateDomainRecordResponse, <-chan error) {
-	responseChan := make(chan *UpdateDomainRecordResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.UpdateDomainRecord(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *UpdateDomainRecordResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.UpdateDomainRecord(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) UpdateDomainRecordWithCallback(request *UpdateDomainRecordRequest, callback func(response *UpdateDomainRecordResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *UpdateDomainRecordResponse
-		var err error
-		defer close(result)
-		response, err = client.UpdateDomainRecord(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) UpdateDomainRecordWithCallback(request *UpdateDomainRecordRequest, callback func(response *UpdateDomainRecordResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *UpdateDomainRecordResponse
+var err error
+defer close(result)
+response, err = client.UpdateDomainRecord(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type UpdateDomainRecordRequest struct {
-	*requests.RpcRequest
-	Priority     string `position:"Query" name:"Priority"`
-	Value        string `position:"Query" name:"Value"`
-	RR           string `position:"Query" name:"RR"`
-	Line         string `position:"Query" name:"Line"`
-	TTL          string `position:"Query" name:"TTL"`
-	Type         string `position:"Query" name:"Type"`
-	UserClientIp string `position:"Query" name:"UserClientIp"`
-	Lang         string `position:"Query" name:"Lang"`
-	RecordId     string `position:"Query" name:"RecordId"`
+*requests.RpcRequest
+                Priority  string `position:"Query" name:"Priority"`
+                Value  string `position:"Query" name:"Value"`
+                RR  string `position:"Query" name:"RR"`
+                Line  string `position:"Query" name:"Line"`
+                TTL  string `position:"Query" name:"TTL"`
+                Type  string `position:"Query" name:"Type"`
+                UserClientIp  string `position:"Query" name:"UserClientIp"`
+                Lang  string `position:"Query" name:"Lang"`
+                RecordId  string `position:"Query" name:"RecordId"`
 }
 
+
 type UpdateDomainRecordResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId" xml:"RequestId"`
-	RecordId  string `json:"RecordId" xml:"RecordId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            RecordId     string `json:"RecordId" xml:"RecordId"`
 }
 
 func CreateUpdateDomainRecordRequest() (request *UpdateDomainRecordRequest) {
-	request = &UpdateDomainRecordRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateDomainRecord", "", "")
-	return
+request = &UpdateDomainRecordRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateDomainRecord", "", "")
+return
 }
 
 func CreateUpdateDomainRecordResponse() (response *UpdateDomainRecordResponse) {
-	response = &UpdateDomainRecordResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &UpdateDomainRecordResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/arms/a_r_m_s_query_data_set.go

@@ -1,3 +1,4 @@
+
 package arms
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,102 +17,103 @@ package arms
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ARMSQueryDataSet(request *ARMSQueryDataSetRequest) (response *ARMSQueryDataSetResponse, err error) {
-	response = CreateARMSQueryDataSetResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateARMSQueryDataSetResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ARMSQueryDataSetWithChan(request *ARMSQueryDataSetRequest) (<-chan *ARMSQueryDataSetResponse, <-chan error) {
-	responseChan := make(chan *ARMSQueryDataSetResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ARMSQueryDataSet(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ARMSQueryDataSetResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ARMSQueryDataSet(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ARMSQueryDataSetWithCallback(request *ARMSQueryDataSetRequest, callback func(response *ARMSQueryDataSetResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ARMSQueryDataSetResponse
-		var err error
-		defer close(result)
-		response, err = client.ARMSQueryDataSet(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ARMSQueryDataSetWithCallback(request *ARMSQueryDataSetRequest, callback func(response *ARMSQueryDataSetResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ARMSQueryDataSetResponse
+var err error
+defer close(result)
+response, err = client.ARMSQueryDataSet(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ARMSQueryDataSetRequest struct {
-	*requests.RpcRequest
-	DateStr       string                          `position:"Query" name:"DateStr"`
-	MinTime       string                          `position:"Query" name:"MinTime"`
-	ReduceTail    string                          `position:"Query" name:"ReduceTail"`
-	MaxTime       string                          `position:"Query" name:"MaxTime"`
-	OptionalDims  *[]ARMSQueryDataSetOptionalDims `position:"Query" name:"OptionalDims"  type:"Repeated"`
-	Measures      *[]string                       `position:"Query" name:"Measures"  type:"Repeated"`
-	IntervalInSec string                          `position:"Query" name:"IntervalInSec"`
-	IsDrillDown   string                          `position:"Query" name:"IsDrillDown"`
-	HungryMode    string                          `position:"Query" name:"HungryMode"`
-	OrderByKey    string                          `position:"Query" name:"OrderByKey"`
-	Limit         string                          `position:"Query" name:"Limit"`
-	DatasetId     string                          `position:"Query" name:"DatasetId"`
-	RequiredDims  *[]ARMSQueryDataSetRequiredDims `position:"Query" name:"RequiredDims"  type:"Repeated"`
-	Dimensions    *[]ARMSQueryDataSetDimensions   `position:"Query" name:"Dimensions"  type:"Repeated"`
+*requests.RpcRequest
+                Limit  string `position:"Query" name:"Limit"`
+                IntervalInSec  string `position:"Query" name:"IntervalInSec"`
+                RequiredDims  *[]ARMSQueryDataSetRequiredDims `position:"Query" name:"RequiredDims"  type:"Repeated"`
+                DatasetId  string `position:"Query" name:"DatasetId"`
+                ReduceTail  string `position:"Query" name:"ReduceTail"`
+                OptionalDims  *[]ARMSQueryDataSetOptionalDims `position:"Query" name:"OptionalDims"  type:"Repeated"`
+                MinTime  string `position:"Query" name:"MinTime"`
+                MaxTime  string `position:"Query" name:"MaxTime"`
+                IsDrillDown  string `position:"Query" name:"IsDrillDown"`
+                DateStr  string `position:"Query" name:"DateStr"`
+                Dimensions  *[]ARMSQueryDataSetDimensions `position:"Query" name:"Dimensions"  type:"Repeated"`
+                OrderByKey  string `position:"Query" name:"OrderByKey"`
+                Measures  *[]string `position:"Query" name:"Measures"  type:"Repeated"`
+                HungryMode  string `position:"Query" name:"HungryMode"`
 }
 
-type ARMSQueryDataSetOptionalDims struct {
-	Key   string `name:"Key"`
-	Value string `name:"Value"`
-	Type  string `name:"Type"`
+type ARMSQueryDataSetRequiredDims struct{
+        Key string `name:"Key"`
+        Value string `name:"Value"`
+        Type string `name:"Type"`
 }
-type ARMSQueryDataSetRequiredDims struct {
-	Key   string `name:"Key"`
-	Value string `name:"Value"`
-	Type  string `name:"Type"`
+type ARMSQueryDataSetOptionalDims struct{
+        Key string `name:"Key"`
+        Value string `name:"Value"`
+        Type string `name:"Type"`
 }
-type ARMSQueryDataSetDimensions struct {
-	Key   string `name:"Key"`
-	Value string `name:"Value"`
-	Type  string `name:"Type"`
+type ARMSQueryDataSetDimensions struct{
+        Key string `name:"Key"`
+        Value string `name:"Value"`
+        Type string `name:"Type"`
 }
 
 type ARMSQueryDataSetResponse struct {
-	*responses.BaseResponse
-	Data string `json:"Data"`
+*responses.BaseResponse
+            Data     string `json:"Data" xml:"Data"`
 }
 
 func CreateARMSQueryDataSetRequest() (request *ARMSQueryDataSetRequest) {
-	request = &ARMSQueryDataSetRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("ARMS", "2016-11-25", "ARMSQueryDataSet", "", "")
-	return
+request = &ARMSQueryDataSetRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("ARMS", "2016-11-25", "ARMSQueryDataSet", "", "")
+return
 }
 
 func CreateARMSQueryDataSetResponse() (response *ARMSQueryDataSetResponse) {
-	response = &ARMSQueryDataSetResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ARMSQueryDataSetResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/arms/client.go

@@ -1,3 +1,4 @@
+
 package arms
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,28 +17,28 @@ package arms
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth"
+    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
+    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth"
 )
 
 type Client struct {
-	sdk.Client
+    sdk.Client
 }
 
 func NewClient() (client *Client, err error) {
-	client = &Client{}
-	err = client.Init()
-	return
+    client = &Client{}
+    err = client.Init()
+    return
 }
 
 func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error) {
-	client = &Client{}
-	err = client.InitWithOptions(regionId, config, credential)
-	return
+    client = &Client{}
+    err = client.InitWithOptions(regionId, config, credential)
+    return
 }
 
 func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error) {
-	client = &Client{}
-	err = client.InitWithAccessKey(regionId, accessKeyId, accessKeySecret)
-	return
+    client = &Client{}
+    err = client.InitWithAccessKey(regionId, accessKeyId, accessKeySecret)
+    return
 }

services/arms/where_in_dim_query.go

@@ -1,3 +1,4 @@
+
 package arms
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,91 +17,92 @@ package arms
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) WhereInDimQuery(request *WhereInDimQueryRequest) (response *WhereInDimQueryResponse, err error) {
-	response = CreateWhereInDimQueryResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateWhereInDimQueryResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) WhereInDimQueryWithChan(request *WhereInDimQueryRequest) (<-chan *WhereInDimQueryResponse, <-chan error) {
-	responseChan := make(chan *WhereInDimQueryResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.WhereInDimQuery(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *WhereInDimQueryResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.WhereInDimQuery(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) WhereInDimQueryWithCallback(request *WhereInDimQueryRequest, callback func(response *WhereInDimQueryResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *WhereInDimQueryResponse
-		var err error
-		defer close(result)
-		response, err = client.WhereInDimQuery(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) WhereInDimQueryWithCallback(request *WhereInDimQueryRequest, callback func(response *WhereInDimQueryResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *WhereInDimQueryResponse
+var err error
+defer close(result)
+response, err = client.WhereInDimQuery(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type WhereInDimQueryRequest struct {
-	*requests.RpcRequest
-	DateStr       string                       `position:"Query" name:"DateStr"`
-	MinTime       string                       `position:"Query" name:"MinTime"`
-	ReduceTail    string                       `position:"Query" name:"ReduceTail"`
-	MaxTime       string                       `position:"Query" name:"MaxTime"`
-	WhereInKey    string                       `position:"Query" name:"WhereInKey"`
-	Measures      *[]string                    `position:"Query" name:"Measures"  type:"Repeated"`
-	IntervalInSec string                       `position:"Query" name:"IntervalInSec"`
-	IsDrillDown   string                       `position:"Query" name:"IsDrillDown"`
-	OrderByKey    string                       `position:"Query" name:"OrderByKey"`
-	Limit         string                       `position:"Query" name:"Limit"`
-	DatasetId     string                       `position:"Query" name:"DatasetId"`
-	WhereInValues *[]string                    `position:"Query" name:"WhereInValues"  type:"Repeated"`
-	Dimensions    *[]WhereInDimQueryDimensions `position:"Query" name:"Dimensions"  type:"Repeated"`
+*requests.RpcRequest
+                Limit  string `position:"Query" name:"Limit"`
+                IntervalInSec  string `position:"Query" name:"IntervalInSec"`
+                DatasetId  string `position:"Query" name:"DatasetId"`
+                ReduceTail  string `position:"Query" name:"ReduceTail"`
+                MinTime  string `position:"Query" name:"MinTime"`
+                MaxTime  string `position:"Query" name:"MaxTime"`
+                IsDrillDown  string `position:"Query" name:"IsDrillDown"`
+                DateStr  string `position:"Query" name:"DateStr"`
+                WhereInValues  *[]string `position:"Query" name:"WhereInValues"  type:"Repeated"`
+                Dimensions  *[]WhereInDimQueryDimensions `position:"Query" name:"Dimensions"  type:"Repeated"`
+                WhereInKey  string `position:"Query" name:"WhereInKey"`
+                OrderByKey  string `position:"Query" name:"OrderByKey"`
+                Measures  *[]string `position:"Query" name:"Measures"  type:"Repeated"`
 }
 
-type WhereInDimQueryDimensions struct {
-	Key   string `name:"Key"`
-	Value string `name:"Value"`
-	Type  string `name:"Type"`
+type WhereInDimQueryDimensions struct{
+        Key string `name:"Key"`
+        Value string `name:"Value"`
+        Type string `name:"Type"`
 }
 
 type WhereInDimQueryResponse struct {
-	*responses.BaseResponse
-	Data string `json:"Data"`
+*responses.BaseResponse
+            Data     string `json:"Data" xml:"Data"`
 }
 
 func CreateWhereInDimQueryRequest() (request *WhereInDimQueryRequest) {
-	request = &WhereInDimQueryRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("ARMS", "2016-11-25", "WhereInDimQuery", "", "")
-	return
+request = &WhereInDimQueryRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("ARMS", "2016-11-25", "WhereInDimQuery", "", "")
+return
 }
 
 func CreateWhereInDimQueryResponse() (response *WhereInDimQueryResponse) {
-	response = &WhereInDimQueryResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &WhereInDimQueryResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/arms4finance/a_r_m_s_query_data_set.go

@@ -1,3 +1,4 @@
+
 package arms4finance
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,85 +17,86 @@ package arms4finance
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ARMSQueryDataSet(request *ARMSQueryDataSetRequest) (response *ARMSQueryDataSetResponse, err error) {
-	response = CreateARMSQueryDataSetResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateARMSQueryDataSetResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ARMSQueryDataSetWithChan(request *ARMSQueryDataSetRequest) (<-chan *ARMSQueryDataSetResponse, <-chan error) {
-	responseChan := make(chan *ARMSQueryDataSetResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ARMSQueryDataSet(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ARMSQueryDataSetResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ARMSQueryDataSet(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ARMSQueryDataSetWithCallback(request *ARMSQueryDataSetRequest, callback func(response *ARMSQueryDataSetResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ARMSQueryDataSetResponse
-		var err error
-		defer close(result)
-		response, err = client.ARMSQueryDataSet(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ARMSQueryDataSetWithCallback(request *ARMSQueryDataSetRequest, callback func(response *ARMSQueryDataSetResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ARMSQueryDataSetResponse
+var err error
+defer close(result)
+response, err = client.ARMSQueryDataSet(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ARMSQueryDataSetRequest struct {
-	*requests.RpcRequest
-	Measures      *[]string                     `position:"Query" name:"Measures"  type:"Repeated"`
-	IntervalInSec string                        `position:"Query" name:"IntervalInSec"`
-	DateStr       string                        `position:"Query" name:"DateStr"`
-	IsDrillDown   string                        `position:"Query" name:"IsDrillDown"`
-	MinTime       string                        `position:"Query" name:"MinTime"`
-	DatasetId     string                        `position:"Query" name:"DatasetId"`
-	MaxTime       string                        `position:"Query" name:"MaxTime"`
-	Dimensions    *[]ARMSQueryDataSetDimensions `position:"Query" name:"Dimensions"  type:"Repeated"`
+*requests.RpcRequest
+                MaxTime  string `position:"Query" name:"MaxTime"`
+                IntervalInSec  string `position:"Query" name:"IntervalInSec"`
+                IsDrillDown  string `position:"Query" name:"IsDrillDown"`
+                DatasetId  string `position:"Query" name:"DatasetId"`
+                DateStr  string `position:"Query" name:"DateStr"`
+                Dimensions  *[]ARMSQueryDataSetDimensions `position:"Query" name:"Dimensions"  type:"Repeated"`
+                Measures  *[]string `position:"Query" name:"Measures"  type:"Repeated"`
+                MinTime  string `position:"Query" name:"MinTime"`
 }
 
-type ARMSQueryDataSetDimensions struct {
-	Key   string `name:"Key"`
-	Value string `name:"Value"`
+type ARMSQueryDataSetDimensions struct{
+        Key string `name:"Key"`
+        Value string `name:"Value"`
 }
 
 type ARMSQueryDataSetResponse struct {
-	*responses.BaseResponse
-	Data string `json:"Data"`
+*responses.BaseResponse
+            Data     string `json:"Data" xml:"Data"`
 }
 
 func CreateARMSQueryDataSetRequest() (request *ARMSQueryDataSetRequest) {
-	request = &ARMSQueryDataSetRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("ARMS4FINANCE", "2017-11-30", "ARMSQueryDataSet", "", "")
-	return
+request = &ARMSQueryDataSetRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("ARMS4FINANCE", "2017-11-30", "ARMSQueryDataSet", "", "")
+return
 }
 
 func CreateARMSQueryDataSetResponse() (response *ARMSQueryDataSetResponse) {
-	response = &ARMSQueryDataSetResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ARMSQueryDataSetResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/arms4finance/client.go

@@ -1,3 +1,4 @@
+
 package arms4finance
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,28 +17,28 @@ package arms4finance
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth"
+    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
+    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth"
 )
 
 type Client struct {
-	sdk.Client
+    sdk.Client
 }
 
 func NewClient() (client *Client, err error) {
-	client = &Client{}
-	err = client.Init()
-	return
+    client = &Client{}
+    err = client.Init()
+    return
 }
 
 func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error) {
-	client = &Client{}
-	err = client.InitWithOptions(regionId, config, credential)
-	return
+    client = &Client{}
+    err = client.InitWithOptions(regionId, config, credential)
+    return
 }
 
 func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error) {
-	client = &Client{}
-	err = client.InitWithAccessKey(regionId, accessKeyId, accessKeySecret)
-	return
+    client = &Client{}
+    err = client.InitWithAccessKey(regionId, accessKeyId, accessKeySecret)
+    return
 }

services/arms4finance/where_in_dim_query.go

@@ -1,3 +1,4 @@
+
 package arms4finance
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,87 +17,88 @@ package arms4finance
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) WhereInDimQuery(request *WhereInDimQueryRequest) (response *WhereInDimQueryResponse, err error) {
-	response = CreateWhereInDimQueryResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateWhereInDimQueryResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) WhereInDimQueryWithChan(request *WhereInDimQueryRequest) (<-chan *WhereInDimQueryResponse, <-chan error) {
-	responseChan := make(chan *WhereInDimQueryResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.WhereInDimQuery(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *WhereInDimQueryResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.WhereInDimQuery(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) WhereInDimQueryWithCallback(request *WhereInDimQueryRequest, callback func(response *WhereInDimQueryResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *WhereInDimQueryResponse
-		var err error
-		defer close(result)
-		response, err = client.WhereInDimQuery(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) WhereInDimQueryWithCallback(request *WhereInDimQueryRequest, callback func(response *WhereInDimQueryResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *WhereInDimQueryResponse
+var err error
+defer close(result)
+response, err = client.WhereInDimQuery(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type WhereInDimQueryRequest struct {
-	*requests.RpcRequest
-	WhereInKey    string                       `position:"Query" name:"WhereInKey"`
-	Measures      *[]string                    `position:"Query" name:"Measures"  type:"Repeated"`
-	IntervalInSec string                       `position:"Query" name:"IntervalInSec"`
-	DateStr       string                       `position:"Query" name:"DateStr"`
-	IsDrillDown   string                       `position:"Query" name:"IsDrillDown"`
-	MinTime       string                       `position:"Query" name:"MinTime"`
-	DatasetId     string                       `position:"Query" name:"DatasetId"`
-	WhereInValues *[]string                    `position:"Query" name:"WhereInValues"  type:"Repeated"`
-	MaxTime       string                       `position:"Query" name:"MaxTime"`
-	Dimensions    *[]WhereInDimQueryDimensions `position:"Query" name:"Dimensions"  type:"Repeated"`
+*requests.RpcRequest
+                MaxTime  string `position:"Query" name:"MaxTime"`
+                IntervalInSec  string `position:"Query" name:"IntervalInSec"`
+                IsDrillDown  string `position:"Query" name:"IsDrillDown"`
+                DatasetId  string `position:"Query" name:"DatasetId"`
+                DateStr  string `position:"Query" name:"DateStr"`
+                WhereInValues  *[]string `position:"Query" name:"WhereInValues"  type:"Repeated"`
+                Dimensions  *[]WhereInDimQueryDimensions `position:"Query" name:"Dimensions"  type:"Repeated"`
+                WhereInKey  string `position:"Query" name:"WhereInKey"`
+                Measures  *[]string `position:"Query" name:"Measures"  type:"Repeated"`
+                MinTime  string `position:"Query" name:"MinTime"`
 }
 
-type WhereInDimQueryDimensions struct {
-	Key   string `name:"Key"`
-	Value string `name:"Value"`
+type WhereInDimQueryDimensions struct{
+        Key string `name:"Key"`
+        Value string `name:"Value"`
 }
 
 type WhereInDimQueryResponse struct {
-	*responses.BaseResponse
-	Data string `json:"Data"`
+*responses.BaseResponse
+            Data     string `json:"Data" xml:"Data"`
 }
 
 func CreateWhereInDimQueryRequest() (request *WhereInDimQueryRequest) {
-	request = &WhereInDimQueryRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("ARMS4FINANCE", "2017-11-30", "WhereInDimQuery", "", "")
-	return
+request = &WhereInDimQueryRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("ARMS4FINANCE", "2017-11-30", "WhereInDimQuery", "", "")
+return
 }
 
 func CreateWhereInDimQueryResponse() (response *WhereInDimQueryResponse) {
-	response = &WhereInDimQueryResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &WhereInDimQueryResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/add_phone_number.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,99 +17,100 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddPhoneNumber(request *AddPhoneNumberRequest) (response *AddPhoneNumberResponse, err error) {
-	response = CreateAddPhoneNumberResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateAddPhoneNumberResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) AddPhoneNumberWithChan(request *AddPhoneNumberRequest) (<-chan *AddPhoneNumberResponse, <-chan error) {
-	responseChan := make(chan *AddPhoneNumberResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.AddPhoneNumber(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *AddPhoneNumberResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.AddPhoneNumber(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) AddPhoneNumberWithCallback(request *AddPhoneNumberRequest, callback func(response *AddPhoneNumberResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *AddPhoneNumberResponse
-		var err error
-		defer close(result)
-		response, err = client.AddPhoneNumber(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) AddPhoneNumberWithCallback(request *AddPhoneNumberRequest, callback func(response *AddPhoneNumberResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *AddPhoneNumberResponse
+var err error
+defer close(result)
+response, err = client.AddPhoneNumber(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type AddPhoneNumberRequest struct {
-	*requests.RpcRequest
-	ContactFlowId string `position:"Query" name:"ContactFlowId"`
-	InstanceId    string `position:"Query" name:"InstanceId"`
-	Usage         string `position:"Query" name:"Usage"`
-	PhoneNumber   string `position:"Query" name:"PhoneNumber"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                PhoneNumber  string `position:"Query" name:"PhoneNumber"`
+                Usage  string `position:"Query" name:"Usage"`
+                ContactFlowId  string `position:"Query" name:"ContactFlowId"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type AddPhoneNumberResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
-	PhoneNumber    struct {
-		PhoneNumberId          string `json:"PhoneNumberId"`
-		InstanceId             string `json:"InstanceId"`
-		Number                 string `json:"Number"`
-		PhoneNumberDescription string `json:"PhoneNumberDescription"`
-		TestOnly               bool   `json:"TestOnly"`
-		RemainingTime          int    `json:"RemainingTime"`
-		AllowOutbound          bool   `json:"AllowOutbound"`
-		Usage                  string `json:"Usage"`
-		Trunks                 int    `json:"Trunks"`
-		ContactFlow            struct {
-			ContactFlowId          string `json:"ContactFlowId"`
-			InstanceId             string `json:"InstanceId"`
-			ContactFlowName        string `json:"ContactFlowName"`
-			ContactFlowDescription string `json:"ContactFlowDescription"`
-			Type                   string `json:"Type"`
-		} `json:"ContactFlow"`
-	} `json:"PhoneNumber"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+            PhoneNumber struct {
+            PhoneNumberId     string `json:"PhoneNumberId" xml:"PhoneNumberId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            Number     string `json:"Number" xml:"Number"`
+            PhoneNumberDescription     string `json:"PhoneNumberDescription" xml:"PhoneNumberDescription"`
+            TestOnly     bool `json:"TestOnly" xml:"TestOnly"`
+            RemainingTime     int `json:"RemainingTime" xml:"RemainingTime"`
+            AllowOutbound     bool `json:"AllowOutbound" xml:"AllowOutbound"`
+            Usage     string `json:"Usage" xml:"Usage"`
+            Trunks     int `json:"Trunks" xml:"Trunks"`
+            ContactFlow struct {
+            ContactFlowId     string `json:"ContactFlowId" xml:"ContactFlowId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            ContactFlowName     string `json:"ContactFlowName" xml:"ContactFlowName"`
+            ContactFlowDescription     string `json:"ContactFlowDescription" xml:"ContactFlowDescription"`
+            Type     string `json:"Type" xml:"Type"`
+            }  `json:"ContactFlow" xml:"ContactFlow"`
+            }  `json:"PhoneNumber" xml:"PhoneNumber"`
 }
 
 func CreateAddPhoneNumberRequest() (request *AddPhoneNumberRequest) {
-	request = &AddPhoneNumberRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "AddPhoneNumber", "", "")
-	return
+request = &AddPhoneNumberRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "AddPhoneNumber", "", "")
+return
 }
 
 func CreateAddPhoneNumberResponse() (response *AddPhoneNumberResponse) {
-	response = &AddPhoneNumberResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &AddPhoneNumberResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/assign_users.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,82 +17,83 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AssignUsers(request *AssignUsersRequest) (response *AssignUsersResponse, err error) {
-	response = CreateAssignUsersResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateAssignUsersResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) AssignUsersWithChan(request *AssignUsersRequest) (<-chan *AssignUsersResponse, <-chan error) {
-	responseChan := make(chan *AssignUsersResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.AssignUsers(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *AssignUsersResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.AssignUsers(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) AssignUsersWithCallback(request *AssignUsersRequest, callback func(response *AssignUsersResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *AssignUsersResponse
-		var err error
-		defer close(result)
-		response, err = client.AssignUsers(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) AssignUsersWithCallback(request *AssignUsersRequest, callback func(response *AssignUsersResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *AssignUsersResponse
+var err error
+defer close(result)
+response, err = client.AssignUsers(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type AssignUsersRequest struct {
-	*requests.RpcRequest
-	UserRamId    *[]string `position:"Query" name:"UserRamId"  type:"Repeated"`
-	SkillLevel   *[]string `position:"Query" name:"SkillLevel"  type:"Repeated"`
-	InstanceId   string    `position:"Query" name:"InstanceId"`
-	RoleId       *[]string `position:"Query" name:"RoleId"  type:"Repeated"`
-	SkillGroupId *[]string `position:"Query" name:"SkillGroupId"  type:"Repeated"`
-	AccessKeyId  string    `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                UserRamId  *[]string `position:"Query" name:"UserRamId"  type:"Repeated"`
+                SkillLevel  *[]string `position:"Query" name:"SkillLevel"  type:"Repeated"`
+                RoleId  *[]string `position:"Query" name:"RoleId"  type:"Repeated"`
+                SkillGroupId  *[]string `position:"Query" name:"SkillGroupId"  type:"Repeated"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type AssignUsersResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
 }
 
 func CreateAssignUsersRequest() (request *AssignUsersRequest) {
-	request = &AssignUsersRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "AssignUsers", "", "")
-	return
+request = &AssignUsersRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "AssignUsers", "", "")
+return
 }
 
 func CreateAssignUsersResponse() (response *AssignUsersResponse) {
-	response = &AssignUsersResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &AssignUsersResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/client.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,28 +17,28 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth"
+    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
+    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth"
 )
 
 type Client struct {
-	sdk.Client
+    sdk.Client
 }
 
 func NewClient() (client *Client, err error) {
-	client = &Client{}
-	err = client.Init()
-	return
+    client = &Client{}
+    err = client.Init()
+    return
 }
 
 func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error) {
-	client = &Client{}
-	err = client.InitWithOptions(regionId, config, credential)
-	return
+    client = &Client{}
+    err = client.InitWithOptions(regionId, config, credential)
+    return
 }
 
 func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error) {
-	client = &Client{}
-	err = client.InitWithAccessKey(regionId, accessKeyId, accessKeySecret)
-	return
+    client = &Client{}
+    err = client.InitWithAccessKey(regionId, accessKeyId, accessKeySecret)
+    return
 }

services/ccc/create_skill_group.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,84 +17,85 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) CreateSkillGroup(request *CreateSkillGroupRequest) (response *CreateSkillGroupResponse, err error) {
-	response = CreateCreateSkillGroupResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateCreateSkillGroupResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) CreateSkillGroupWithChan(request *CreateSkillGroupRequest) (<-chan *CreateSkillGroupResponse, <-chan error) {
-	responseChan := make(chan *CreateSkillGroupResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.CreateSkillGroup(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *CreateSkillGroupResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.CreateSkillGroup(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) CreateSkillGroupWithCallback(request *CreateSkillGroupRequest, callback func(response *CreateSkillGroupResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *CreateSkillGroupResponse
-		var err error
-		defer close(result)
-		response, err = client.CreateSkillGroup(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) CreateSkillGroupWithCallback(request *CreateSkillGroupRequest, callback func(response *CreateSkillGroupResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *CreateSkillGroupResponse
+var err error
+defer close(result)
+response, err = client.CreateSkillGroup(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type CreateSkillGroupRequest struct {
-	*requests.RpcRequest
-	SkillLevel            *[]string `position:"Query" name:"SkillLevel"  type:"Repeated"`
-	InstanceId            string    `position:"Query" name:"InstanceId"`
-	OutboundPhoneNumberId *[]string `position:"Query" name:"OutboundPhoneNumberId"  type:"Repeated"`
-	Name                  string    `position:"Query" name:"Name"`
-	Description           string    `position:"Query" name:"Description"`
-	UserId                *[]string `position:"Query" name:"UserId"  type:"Repeated"`
-	AccessKeyId           string    `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                SkillLevel  *[]string `position:"Query" name:"SkillLevel"  type:"Repeated"`
+                Description  string `position:"Query" name:"Description"`
+                Name  string `position:"Query" name:"Name"`
+                UserId  *[]string `position:"Query" name:"UserId"  type:"Repeated"`
+                OutboundPhoneNumberId  *[]string `position:"Query" name:"OutboundPhoneNumberId"  type:"Repeated"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type CreateSkillGroupResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
-	SkillGroupId   string `json:"SkillGroupId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+            SkillGroupId     string `json:"SkillGroupId" xml:"SkillGroupId"`
 }
 
 func CreateCreateSkillGroupRequest() (request *CreateSkillGroupRequest) {
-	request = &CreateSkillGroupRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "CreateSkillGroup", "", "")
-	return
+request = &CreateSkillGroupRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "CreateSkillGroup", "", "")
+return
 }
 
 func CreateCreateSkillGroupResponse() (response *CreateSkillGroupResponse) {
-	response = &CreateSkillGroupResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &CreateSkillGroupResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/create_user.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,86 +17,87 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) CreateUser(request *CreateUserRequest) (response *CreateUserResponse, err error) {
-	response = CreateCreateUserResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateCreateUserResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) CreateUserWithChan(request *CreateUserRequest) (<-chan *CreateUserResponse, <-chan error) {
-	responseChan := make(chan *CreateUserResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.CreateUser(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *CreateUserResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.CreateUser(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) CreateUserWithCallback(request *CreateUserRequest, callback func(response *CreateUserResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *CreateUserResponse
-		var err error
-		defer close(result)
-		response, err = client.CreateUser(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) CreateUserWithCallback(request *CreateUserRequest, callback func(response *CreateUserResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *CreateUserResponse
+var err error
+defer close(result)
+response, err = client.CreateUser(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type CreateUserRequest struct {
-	*requests.RpcRequest
-	SkillLevel   *[]string `position:"Query" name:"SkillLevel"  type:"Repeated"`
-	InstanceId   string    `position:"Query" name:"InstanceId"`
-	LoginName    string    `position:"Query" name:"LoginName"`
-	Phone        string    `position:"Query" name:"Phone"`
-	RoleId       *[]string `position:"Query" name:"RoleId"  type:"Repeated"`
-	DisplayName  string    `position:"Query" name:"DisplayName"`
-	SkillGroupId *[]string `position:"Query" name:"SkillGroupId"  type:"Repeated"`
-	Email        string    `position:"Query" name:"Email"`
-	AccessKeyId  string    `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                LoginName  string `position:"Query" name:"LoginName"`
+                Phone  string `position:"Query" name:"Phone"`
+                SkillLevel  *[]string `position:"Query" name:"SkillLevel"  type:"Repeated"`
+                RoleId  *[]string `position:"Query" name:"RoleId"  type:"Repeated"`
+                Email  string `position:"Query" name:"Email"`
+                SkillGroupId  *[]string `position:"Query" name:"SkillGroupId"  type:"Repeated"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
+                DisplayName  string `position:"Query" name:"DisplayName"`
 }
 
+
 type CreateUserResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
-	UserId         string `json:"UserId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+            UserId     string `json:"UserId" xml:"UserId"`
 }
 
 func CreateCreateUserRequest() (request *CreateUserRequest) {
-	request = &CreateUserRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "CreateUser", "", "")
-	return
+request = &CreateUserRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "CreateUser", "", "")
+return
 }
 
 func CreateCreateUserResponse() (response *CreateUserResponse) {
-	response = &CreateUserResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &CreateUserResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/delete_skill_group.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,79 +17,80 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteSkillGroup(request *DeleteSkillGroupRequest) (response *DeleteSkillGroupResponse, err error) {
-	response = CreateDeleteSkillGroupResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDeleteSkillGroupResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DeleteSkillGroupWithChan(request *DeleteSkillGroupRequest) (<-chan *DeleteSkillGroupResponse, <-chan error) {
-	responseChan := make(chan *DeleteSkillGroupResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DeleteSkillGroup(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DeleteSkillGroupResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DeleteSkillGroup(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DeleteSkillGroupWithCallback(request *DeleteSkillGroupRequest, callback func(response *DeleteSkillGroupResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DeleteSkillGroupResponse
-		var err error
-		defer close(result)
-		response, err = client.DeleteSkillGroup(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DeleteSkillGroupWithCallback(request *DeleteSkillGroupRequest, callback func(response *DeleteSkillGroupResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DeleteSkillGroupResponse
+var err error
+defer close(result)
+response, err = client.DeleteSkillGroup(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DeleteSkillGroupRequest struct {
-	*requests.RpcRequest
-	InstanceId   string `position:"Query" name:"InstanceId"`
-	SkillGroupId string `position:"Query" name:"SkillGroupId"`
-	AccessKeyId  string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                SkillGroupId  string `position:"Query" name:"SkillGroupId"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type DeleteSkillGroupResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
 }
 
 func CreateDeleteSkillGroupRequest() (request *DeleteSkillGroupRequest) {
-	request = &DeleteSkillGroupRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "DeleteSkillGroup", "", "")
-	return
+request = &DeleteSkillGroupRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "DeleteSkillGroup", "", "")
+return
 }
 
 func CreateDeleteSkillGroupResponse() (response *DeleteSkillGroupResponse) {
-	response = &DeleteSkillGroupResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DeleteSkillGroupResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/get_config.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,85 +17,86 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) GetConfig(request *GetConfigRequest) (response *GetConfigResponse, err error) {
-	response = CreateGetConfigResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateGetConfigResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) GetConfigWithChan(request *GetConfigRequest) (<-chan *GetConfigResponse, <-chan error) {
-	responseChan := make(chan *GetConfigResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.GetConfig(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *GetConfigResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.GetConfig(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) GetConfigWithCallback(request *GetConfigRequest, callback func(response *GetConfigResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *GetConfigResponse
-		var err error
-		defer close(result)
-		response, err = client.GetConfig(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) GetConfigWithCallback(request *GetConfigRequest, callback func(response *GetConfigResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *GetConfigResponse
+var err error
+defer close(result)
+response, err = client.GetConfig(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type GetConfigRequest struct {
-	*requests.RpcRequest
-	InstanceId  string `position:"Query" name:"InstanceId"`
-	Name        string `position:"Query" name:"Name"`
-	ObjectType  string `position:"Query" name:"ObjectType"`
-	ObjectId    string `position:"Query" name:"ObjectId"`
-	AccessKeyId string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                ObjectType  string `position:"Query" name:"ObjectType"`
+                Name  string `position:"Query" name:"Name"`
+                ObjectId  string `position:"Query" name:"ObjectId"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type GetConfigResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
-	ConfigItem     struct {
-		Name  string `json:"Name"`
-		Value string `json:"Value"`
-	} `json:"ConfigItem"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+            ConfigItem struct {
+            Name     string `json:"Name" xml:"Name"`
+            Value     string `json:"Value" xml:"Value"`
+            }  `json:"ConfigItem" xml:"ConfigItem"`
 }
 
 func CreateGetConfigRequest() (request *GetConfigRequest) {
-	request = &GetConfigRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "GetConfig", "", "")
-	return
+request = &GetConfigRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "GetConfig", "", "")
+return
 }
 
 func CreateGetConfigResponse() (response *GetConfigResponse) {
-	response = &GetConfigResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &GetConfigResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/get_service_extensions.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,83 +17,86 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) GetServiceExtensions(request *GetServiceExtensionsRequest) (response *GetServiceExtensionsResponse, err error) {
-	response = CreateGetServiceExtensionsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateGetServiceExtensionsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) GetServiceExtensionsWithChan(request *GetServiceExtensionsRequest) (<-chan *GetServiceExtensionsResponse, <-chan error) {
-	responseChan := make(chan *GetServiceExtensionsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.GetServiceExtensions(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *GetServiceExtensionsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.GetServiceExtensions(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) GetServiceExtensionsWithCallback(request *GetServiceExtensionsRequest, callback func(response *GetServiceExtensionsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *GetServiceExtensionsResponse
-		var err error
-		defer close(result)
-		response, err = client.GetServiceExtensions(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) GetServiceExtensionsWithCallback(request *GetServiceExtensionsRequest, callback func(response *GetServiceExtensionsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *GetServiceExtensionsResponse
+var err error
+defer close(result)
+response, err = client.GetServiceExtensions(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type GetServiceExtensionsRequest struct {
-	*requests.RpcRequest
-	ServiceType string `position:"Query" name:"ServiceType"`
-	InstanceId  string `position:"Query" name:"InstanceId"`
-	AccessKeyId string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                ServiceType  string `position:"Query" name:"ServiceType"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type GetServiceExtensionsResponse struct {
-	*responses.BaseResponse
-	RequestId         string `json:"RequestId"`
-	Success           bool   `json:"Success"`
-	Code              string `json:"Code"`
-	Message           string `json:"Message"`
-	HttpStatusCode    int    `json:"HttpStatusCode"`
-	ServiceExtensions []struct {
-		Name   string `json:"Name"`
-		Number string `json:"Number"`
-	} `json:"ServiceExtensions"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+                ServiceExtensions struct {
+                    ServiceExtension []struct {
+            Name     string `json:"Name" xml:"Name"`
+            Number     string `json:"Number" xml:"Number"`
+                    }   `json:"ServiceExtension" xml:"ServiceExtension"`
+                } `json:"ServiceExtensions" xml:"ServiceExtensions"`
 }
 
 func CreateGetServiceExtensionsRequest() (request *GetServiceExtensionsRequest) {
-	request = &GetServiceExtensionsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "GetServiceExtensions", "", "")
-	return
+request = &GetServiceExtensionsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "GetServiceExtensions", "", "")
+return
 }
 
 func CreateGetServiceExtensionsResponse() (response *GetServiceExtensionsResponse) {
-	response = &GetServiceExtensionsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &GetServiceExtensionsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/get_user.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,107 +17,112 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) GetUser(request *GetUserRequest) (response *GetUserResponse, err error) {
-	response = CreateGetUserResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateGetUserResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) GetUserWithChan(request *GetUserRequest) (<-chan *GetUserResponse, <-chan error) {
-	responseChan := make(chan *GetUserResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.GetUser(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *GetUserResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.GetUser(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) GetUserWithCallback(request *GetUserRequest, callback func(response *GetUserResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *GetUserResponse
-		var err error
-		defer close(result)
-		response, err = client.GetUser(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) GetUserWithCallback(request *GetUserRequest, callback func(response *GetUserResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *GetUserResponse
+var err error
+defer close(result)
+response, err = client.GetUser(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type GetUserRequest struct {
-	*requests.RpcRequest
-	InstanceId  string `position:"Query" name:"InstanceId"`
-	UserId      string `position:"Query" name:"UserId"`
-	AccessKeyId string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                UserId  string `position:"Query" name:"UserId"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type GetUserResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
-	User           struct {
-		UserId     string `json:"UserId"`
-		RamId      string `json:"RamId"`
-		InstanceId string `json:"InstanceId"`
-		Detail     struct {
-			LoginName   string `json:"LoginName"`
-			DisplayName string `json:"DisplayName"`
-			Phone       string `json:"Phone"`
-			Email       string `json:"Email"`
-			Department  string `json:"Department"`
-		} `json:"Detail"`
-		Roles []struct {
-			RoleId          string `json:"RoleId"`
-			InstanceId      string `json:"InstanceId"`
-			RoleName        string `json:"RoleName"`
-			RoleDescription string `json:"RoleDescription"`
-		} `json:"Roles"`
-		SkillLevels []struct {
-			SkillLevelId string `json:"SkillLevelId"`
-			Level        int    `json:"Level"`
-			Skill        struct {
-				SkillGroupId          string `json:"SkillGroupId"`
-				InstanceId            string `json:"InstanceId"`
-				SkillGroupName        string `json:"SkillGroupName"`
-				SkillGroupDescription string `json:"SkillGroupDescription"`
-			} `json:"Skill"`
-		} `json:"SkillLevels"`
-	} `json:"User"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+            User struct {
+            UserId     string `json:"UserId" xml:"UserId"`
+            RamId     string `json:"RamId" xml:"RamId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            Detail struct {
+            LoginName     string `json:"LoginName" xml:"LoginName"`
+            DisplayName     string `json:"DisplayName" xml:"DisplayName"`
+            Phone     string `json:"Phone" xml:"Phone"`
+            Email     string `json:"Email" xml:"Email"`
+            Department     string `json:"Department" xml:"Department"`
+            }  `json:"Detail" xml:"Detail"`
+                Roles struct {
+                    Role []struct {
+            RoleId     string `json:"RoleId" xml:"RoleId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            RoleName     string `json:"RoleName" xml:"RoleName"`
+            RoleDescription     string `json:"RoleDescription" xml:"RoleDescription"`
+                    }   `json:"Role" xml:"Role"`
+                } `json:"Roles" xml:"Roles"`
+                SkillLevels struct {
+                    SkillLevel []struct {
+            SkillLevelId     string `json:"SkillLevelId" xml:"SkillLevelId"`
+            Level     int `json:"Level" xml:"Level"`
+            Skill struct {
+            SkillGroupId     string `json:"SkillGroupId" xml:"SkillGroupId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            SkillGroupName     string `json:"SkillGroupName" xml:"SkillGroupName"`
+            SkillGroupDescription     string `json:"SkillGroupDescription" xml:"SkillGroupDescription"`
+            }  `json:"Skill" xml:"Skill"`
+                    }   `json:"SkillLevel" xml:"SkillLevel"`
+                } `json:"SkillLevels" xml:"SkillLevels"`
+            }  `json:"User" xml:"User"`
 }
 
 func CreateGetUserRequest() (request *GetUserRequest) {
-	request = &GetUserRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "GetUser", "", "")
-	return
+request = &GetUserRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "GetUser", "", "")
+return
 }
 
 func CreateGetUserResponse() (response *GetUserResponse) {
-	response = &GetUserResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &GetUserResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/list_contact_flows.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,106 +17,113 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ListContactFlows(request *ListContactFlowsRequest) (response *ListContactFlowsResponse, err error) {
-	response = CreateListContactFlowsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateListContactFlowsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ListContactFlowsWithChan(request *ListContactFlowsRequest) (<-chan *ListContactFlowsResponse, <-chan error) {
-	responseChan := make(chan *ListContactFlowsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ListContactFlows(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ListContactFlowsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ListContactFlows(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ListContactFlowsWithCallback(request *ListContactFlowsRequest, callback func(response *ListContactFlowsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ListContactFlowsResponse
-		var err error
-		defer close(result)
-		response, err = client.ListContactFlows(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ListContactFlowsWithCallback(request *ListContactFlowsRequest, callback func(response *ListContactFlowsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ListContactFlowsResponse
+var err error
+defer close(result)
+response, err = client.ListContactFlows(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ListContactFlowsRequest struct {
-	*requests.RpcRequest
-	InstanceId  string `position:"Query" name:"InstanceId"`
-	AccessKeyId string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type ListContactFlowsResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
-	ContactFlows   []struct {
-		ContactFlowId          string `json:"ContactFlowId"`
-		InstanceId             string `json:"InstanceId"`
-		ContactFlowName        string `json:"ContactFlowName"`
-		ContactFlowDescription string `json:"ContactFlowDescription"`
-		Type                   string `json:"Type"`
-		AppliedVersion         string `json:"AppliedVersion"`
-		Versions               []struct {
-			ContactFlowVersionId          string `json:"ContactFlowVersionId"`
-			Version                       string `json:"Version"`
-			ContactFlowVersionDescription string `json:"ContactFlowVersionDescription"`
-			LastModified                  string `json:"LastModified"`
-			LastModifiedBy                string `json:"LastModifiedBy"`
-			LockedBy                      string `json:"LockedBy"`
-			Status                        string `json:"Status"`
-		} `json:"Versions"`
-		PhoneNumbers []struct {
-			PhoneNumberId          string `json:"PhoneNumberId"`
-			InstanceId             string `json:"InstanceId"`
-			Number                 string `json:"Number"`
-			PhoneNumberDescription string `json:"PhoneNumberDescription"`
-			TestOnly               bool   `json:"TestOnly"`
-			RemainingTime          int    `json:"RemainingTime"`
-			AllowOutbound          bool   `json:"AllowOutbound"`
-			Usage                  string `json:"Usage"`
-			Trunks                 int    `json:"Trunks"`
-		} `json:"PhoneNumbers"`
-	} `json:"ContactFlows"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+                ContactFlows struct {
+                    ContactFlow []struct {
+            ContactFlowId     string `json:"ContactFlowId" xml:"ContactFlowId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            ContactFlowName     string `json:"ContactFlowName" xml:"ContactFlowName"`
+            ContactFlowDescription     string `json:"ContactFlowDescription" xml:"ContactFlowDescription"`
+            Type     string `json:"Type" xml:"Type"`
+            AppliedVersion     string `json:"AppliedVersion" xml:"AppliedVersion"`
+                Versions struct {
+                    ContactFlowVersion []struct {
+            ContactFlowVersionId     string `json:"ContactFlowVersionId" xml:"ContactFlowVersionId"`
+            Version     string `json:"Version" xml:"Version"`
+            ContactFlowVersionDescription     string `json:"ContactFlowVersionDescription" xml:"ContactFlowVersionDescription"`
+            LastModified     string `json:"LastModified" xml:"LastModified"`
+            LastModifiedBy     string `json:"LastModifiedBy" xml:"LastModifiedBy"`
+            LockedBy     string `json:"LockedBy" xml:"LockedBy"`
+            Status     string `json:"Status" xml:"Status"`
+                    }   `json:"ContactFlowVersion" xml:"ContactFlowVersion"`
+                } `json:"Versions" xml:"Versions"`
+                PhoneNumbers struct {
+                    PhoneNumber []struct {
+            PhoneNumberId     string `json:"PhoneNumberId" xml:"PhoneNumberId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            Number     string `json:"Number" xml:"Number"`
+            PhoneNumberDescription     string `json:"PhoneNumberDescription" xml:"PhoneNumberDescription"`
+            TestOnly     bool `json:"TestOnly" xml:"TestOnly"`
+            RemainingTime     int `json:"RemainingTime" xml:"RemainingTime"`
+            AllowOutbound     bool `json:"AllowOutbound" xml:"AllowOutbound"`
+            Usage     string `json:"Usage" xml:"Usage"`
+            Trunks     int `json:"Trunks" xml:"Trunks"`
+                    }   `json:"PhoneNumber" xml:"PhoneNumber"`
+                } `json:"PhoneNumbers" xml:"PhoneNumbers"`
+                    }   `json:"ContactFlow" xml:"ContactFlow"`
+                } `json:"ContactFlows" xml:"ContactFlows"`
 }
 
 func CreateListContactFlowsRequest() (request *ListContactFlowsRequest) {
-	request = &ListContactFlowsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "ListContactFlows", "", "")
-	return
+request = &ListContactFlowsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "ListContactFlows", "", "")
+return
 }
 
 func CreateListContactFlowsResponse() (response *ListContactFlowsResponse) {
-	response = &ListContactFlowsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ListContactFlowsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/list_phone_numbers.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,97 +17,100 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ListPhoneNumbers(request *ListPhoneNumbersRequest) (response *ListPhoneNumbersResponse, err error) {
-	response = CreateListPhoneNumbersResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateListPhoneNumbersResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ListPhoneNumbersWithChan(request *ListPhoneNumbersRequest) (<-chan *ListPhoneNumbersResponse, <-chan error) {
-	responseChan := make(chan *ListPhoneNumbersResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ListPhoneNumbers(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ListPhoneNumbersResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ListPhoneNumbers(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ListPhoneNumbersWithCallback(request *ListPhoneNumbersRequest, callback func(response *ListPhoneNumbersResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ListPhoneNumbersResponse
-		var err error
-		defer close(result)
-		response, err = client.ListPhoneNumbers(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ListPhoneNumbersWithCallback(request *ListPhoneNumbersRequest, callback func(response *ListPhoneNumbersResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ListPhoneNumbersResponse
+var err error
+defer close(result)
+response, err = client.ListPhoneNumbers(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ListPhoneNumbersRequest struct {
-	*requests.RpcRequest
-	OutboundOnly string `position:"Query" name:"OutboundOnly"`
-	InstanceId   string `position:"Query" name:"InstanceId"`
-	AccessKeyId  string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                OutboundOnly  string `position:"Query" name:"OutboundOnly"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type ListPhoneNumbersResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
-	PhoneNumbers   []struct {
-		PhoneNumberId          string `json:"PhoneNumberId"`
-		InstanceId             string `json:"InstanceId"`
-		Number                 string `json:"Number"`
-		PhoneNumberDescription string `json:"PhoneNumberDescription"`
-		TestOnly               bool   `json:"TestOnly"`
-		RemainingTime          int    `json:"RemainingTime"`
-		AllowOutbound          bool   `json:"AllowOutbound"`
-		Usage                  string `json:"Usage"`
-		Trunks                 int    `json:"Trunks"`
-		ContactFlow            struct {
-			ContactFlowId          string `json:"ContactFlowId"`
-			InstanceId             string `json:"InstanceId"`
-			ContactFlowName        string `json:"ContactFlowName"`
-			ContactFlowDescription string `json:"ContactFlowDescription"`
-			Type                   string `json:"Type"`
-		} `json:"ContactFlow"`
-	} `json:"PhoneNumbers"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+                PhoneNumbers struct {
+                    PhoneNumber []struct {
+            PhoneNumberId     string `json:"PhoneNumberId" xml:"PhoneNumberId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            Number     string `json:"Number" xml:"Number"`
+            PhoneNumberDescription     string `json:"PhoneNumberDescription" xml:"PhoneNumberDescription"`
+            TestOnly     bool `json:"TestOnly" xml:"TestOnly"`
+            RemainingTime     int `json:"RemainingTime" xml:"RemainingTime"`
+            AllowOutbound     bool `json:"AllowOutbound" xml:"AllowOutbound"`
+            Usage     string `json:"Usage" xml:"Usage"`
+            Trunks     int `json:"Trunks" xml:"Trunks"`
+            ContactFlow struct {
+            ContactFlowId     string `json:"ContactFlowId" xml:"ContactFlowId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            ContactFlowName     string `json:"ContactFlowName" xml:"ContactFlowName"`
+            ContactFlowDescription     string `json:"ContactFlowDescription" xml:"ContactFlowDescription"`
+            Type     string `json:"Type" xml:"Type"`
+            }  `json:"ContactFlow" xml:"ContactFlow"`
+                    }   `json:"PhoneNumber" xml:"PhoneNumber"`
+                } `json:"PhoneNumbers" xml:"PhoneNumbers"`
 }
 
 func CreateListPhoneNumbersRequest() (request *ListPhoneNumbersRequest) {
-	request = &ListPhoneNumbersRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "ListPhoneNumbers", "", "")
-	return
+request = &ListPhoneNumbersRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "ListPhoneNumbers", "", "")
+return
 }
 
 func CreateListPhoneNumbersResponse() (response *ListPhoneNumbersResponse) {
-	response = &ListPhoneNumbersResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ListPhoneNumbersResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/list_roles.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,84 +17,87 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ListRoles(request *ListRolesRequest) (response *ListRolesResponse, err error) {
-	response = CreateListRolesResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateListRolesResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ListRolesWithChan(request *ListRolesRequest) (<-chan *ListRolesResponse, <-chan error) {
-	responseChan := make(chan *ListRolesResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ListRoles(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ListRolesResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ListRoles(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ListRolesWithCallback(request *ListRolesRequest, callback func(response *ListRolesResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ListRolesResponse
-		var err error
-		defer close(result)
-		response, err = client.ListRoles(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ListRolesWithCallback(request *ListRolesRequest, callback func(response *ListRolesResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ListRolesResponse
+var err error
+defer close(result)
+response, err = client.ListRoles(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ListRolesRequest struct {
-	*requests.RpcRequest
-	InstanceId  string `position:"Query" name:"InstanceId"`
-	AccessKeyId string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type ListRolesResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
-	Roles          []struct {
-		RoleId          string `json:"RoleId"`
-		InstanceId      string `json:"InstanceId"`
-		RoleName        string `json:"RoleName"`
-		RoleDescription string `json:"RoleDescription"`
-	} `json:"Roles"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+                Roles struct {
+                    Role []struct {
+            RoleId     string `json:"RoleId" xml:"RoleId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            RoleName     string `json:"RoleName" xml:"RoleName"`
+            RoleDescription     string `json:"RoleDescription" xml:"RoleDescription"`
+                    }   `json:"Role" xml:"Role"`
+                } `json:"Roles" xml:"Roles"`
 }
 
 func CreateListRolesRequest() (request *ListRolesRequest) {
-	request = &ListRolesRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "ListRoles", "", "")
-	return
+request = &ListRolesRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "ListRoles", "", "")
+return
 }
 
 func CreateListRolesResponse() (response *ListRolesResponse) {
-	response = &ListRolesResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ListRolesResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/list_skill_groups.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,98 +17,103 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ListSkillGroups(request *ListSkillGroupsRequest) (response *ListSkillGroupsResponse, err error) {
-	response = CreateListSkillGroupsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateListSkillGroupsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ListSkillGroupsWithChan(request *ListSkillGroupsRequest) (<-chan *ListSkillGroupsResponse, <-chan error) {
-	responseChan := make(chan *ListSkillGroupsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ListSkillGroups(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ListSkillGroupsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ListSkillGroups(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ListSkillGroupsWithCallback(request *ListSkillGroupsRequest, callback func(response *ListSkillGroupsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ListSkillGroupsResponse
-		var err error
-		defer close(result)
-		response, err = client.ListSkillGroups(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ListSkillGroupsWithCallback(request *ListSkillGroupsRequest, callback func(response *ListSkillGroupsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ListSkillGroupsResponse
+var err error
+defer close(result)
+response, err = client.ListSkillGroups(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ListSkillGroupsRequest struct {
-	*requests.RpcRequest
-	InstanceId  string `position:"Query" name:"InstanceId"`
-	AccessKeyId string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type ListSkillGroupsResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
-	SkillGroups    []struct {
-		SkillGroupId          string `json:"SkillGroupId"`
-		InstanceId            string `json:"InstanceId"`
-		SkillGroupName        string `json:"SkillGroupName"`
-		AccSkillGroupName     string `json:"AccSkillGroupName"`
-		AccQueueName          string `json:"AccQueueName"`
-		SkillGroupDescription string `json:"SkillGroupDescription"`
-		UserCount             int    `json:"UserCount"`
-		OutboundPhoneNumbers  []struct {
-			PhoneNumberId          string `json:"PhoneNumberId"`
-			InstanceId             string `json:"InstanceId"`
-			Number                 string `json:"Number"`
-			PhoneNumberDescription string `json:"PhoneNumberDescription"`
-			TestOnly               bool   `json:"TestOnly"`
-			RemainingTime          int    `json:"RemainingTime"`
-			AllowOutbound          bool   `json:"AllowOutbound"`
-			Usage                  string `json:"Usage"`
-			Trunks                 int    `json:"Trunks"`
-		} `json:"OutboundPhoneNumbers"`
-	} `json:"SkillGroups"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+                SkillGroups struct {
+                    SkillGroup []struct {
+            SkillGroupId     string `json:"SkillGroupId" xml:"SkillGroupId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            SkillGroupName     string `json:"SkillGroupName" xml:"SkillGroupName"`
+            AccSkillGroupName     string `json:"AccSkillGroupName" xml:"AccSkillGroupName"`
+            AccQueueName     string `json:"AccQueueName" xml:"AccQueueName"`
+            SkillGroupDescription     string `json:"SkillGroupDescription" xml:"SkillGroupDescription"`
+            UserCount     int `json:"UserCount" xml:"UserCount"`
+                OutboundPhoneNumbers struct {
+                    PhoneNumber []struct {
+            PhoneNumberId     string `json:"PhoneNumberId" xml:"PhoneNumberId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            Number     string `json:"Number" xml:"Number"`
+            PhoneNumberDescription     string `json:"PhoneNumberDescription" xml:"PhoneNumberDescription"`
+            TestOnly     bool `json:"TestOnly" xml:"TestOnly"`
+            RemainingTime     int `json:"RemainingTime" xml:"RemainingTime"`
+            AllowOutbound     bool `json:"AllowOutbound" xml:"AllowOutbound"`
+            Usage     string `json:"Usage" xml:"Usage"`
+            Trunks     int `json:"Trunks" xml:"Trunks"`
+                    }   `json:"PhoneNumber" xml:"PhoneNumber"`
+                } `json:"OutboundPhoneNumbers" xml:"OutboundPhoneNumbers"`
+                    }   `json:"SkillGroup" xml:"SkillGroup"`
+                } `json:"SkillGroups" xml:"SkillGroups"`
 }
 
 func CreateListSkillGroupsRequest() (request *ListSkillGroupsRequest) {
-	request = &ListSkillGroupsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "ListSkillGroups", "", "")
-	return
+request = &ListSkillGroupsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "ListSkillGroups", "", "")
+return
 }
 
 func CreateListSkillGroupsResponse() (response *ListSkillGroupsResponse) {
-	response = &ListSkillGroupsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ListSkillGroupsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/list_skill_groups_of_user.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,100 +17,105 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ListSkillGroupsOfUser(request *ListSkillGroupsOfUserRequest) (response *ListSkillGroupsOfUserResponse, err error) {
-	response = CreateListSkillGroupsOfUserResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateListSkillGroupsOfUserResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ListSkillGroupsOfUserWithChan(request *ListSkillGroupsOfUserRequest) (<-chan *ListSkillGroupsOfUserResponse, <-chan error) {
-	responseChan := make(chan *ListSkillGroupsOfUserResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ListSkillGroupsOfUser(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ListSkillGroupsOfUserResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ListSkillGroupsOfUser(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ListSkillGroupsOfUserWithCallback(request *ListSkillGroupsOfUserRequest, callback func(response *ListSkillGroupsOfUserResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ListSkillGroupsOfUserResponse
-		var err error
-		defer close(result)
-		response, err = client.ListSkillGroupsOfUser(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ListSkillGroupsOfUserWithCallback(request *ListSkillGroupsOfUserRequest, callback func(response *ListSkillGroupsOfUserResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ListSkillGroupsOfUserResponse
+var err error
+defer close(result)
+response, err = client.ListSkillGroupsOfUser(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ListSkillGroupsOfUserRequest struct {
-	*requests.RpcRequest
-	InstanceId  string `position:"Query" name:"InstanceId"`
-	UserId      string `position:"Query" name:"UserId"`
-	AccessKeyId string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                UserId  string `position:"Query" name:"UserId"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type ListSkillGroupsOfUserResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
-	SkillLevels    []struct {
-		SkillLevelId string `json:"SkillLevelId"`
-		Level        int    `json:"Level"`
-		Skill        struct {
-			SkillGroupId          string `json:"SkillGroupId"`
-			InstanceId            string `json:"InstanceId"`
-			SkillGroupName        string `json:"SkillGroupName"`
-			SkillGroupDescription string `json:"SkillGroupDescription"`
-			OutboundPhoneNumbers  []struct {
-				PhoneNumberId          string `json:"PhoneNumberId"`
-				InstanceId             string `json:"InstanceId"`
-				Number                 string `json:"Number"`
-				PhoneNumberDescription string `json:"PhoneNumberDescription"`
-				TestOnly               bool   `json:"TestOnly"`
-				RemainingTime          int    `json:"RemainingTime"`
-				AllowOutbound          bool   `json:"AllowOutbound"`
-				Usage                  string `json:"Usage"`
-				Trunks                 int    `json:"Trunks"`
-			} `json:"OutboundPhoneNumbers"`
-		} `json:"Skill"`
-	} `json:"SkillLevels"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+                SkillLevels struct {
+                    SkillLevel []struct {
+            SkillLevelId     string `json:"SkillLevelId" xml:"SkillLevelId"`
+            Level     int `json:"Level" xml:"Level"`
+            Skill struct {
+            SkillGroupId     string `json:"SkillGroupId" xml:"SkillGroupId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            SkillGroupName     string `json:"SkillGroupName" xml:"SkillGroupName"`
+            SkillGroupDescription     string `json:"SkillGroupDescription" xml:"SkillGroupDescription"`
+                OutboundPhoneNumbers struct {
+                    PhoneNumber []struct {
+            PhoneNumberId     string `json:"PhoneNumberId" xml:"PhoneNumberId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            Number     string `json:"Number" xml:"Number"`
+            PhoneNumberDescription     string `json:"PhoneNumberDescription" xml:"PhoneNumberDescription"`
+            TestOnly     bool `json:"TestOnly" xml:"TestOnly"`
+            RemainingTime     int `json:"RemainingTime" xml:"RemainingTime"`
+            AllowOutbound     bool `json:"AllowOutbound" xml:"AllowOutbound"`
+            Usage     string `json:"Usage" xml:"Usage"`
+            Trunks     int `json:"Trunks" xml:"Trunks"`
+                    }   `json:"PhoneNumber" xml:"PhoneNumber"`
+                } `json:"OutboundPhoneNumbers" xml:"OutboundPhoneNumbers"`
+            }  `json:"Skill" xml:"Skill"`
+                    }   `json:"SkillLevel" xml:"SkillLevel"`
+                } `json:"SkillLevels" xml:"SkillLevels"`
 }
 
 func CreateListSkillGroupsOfUserRequest() (request *ListSkillGroupsOfUserRequest) {
-	request = &ListSkillGroupsOfUserRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "ListSkillGroupsOfUser", "", "")
-	return
+request = &ListSkillGroupsOfUserRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "ListSkillGroupsOfUser", "", "")
+return
 }
 
 func CreateListSkillGroupsOfUserResponse() (response *ListSkillGroupsOfUserResponse) {
-	response = &ListSkillGroupsOfUserResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ListSkillGroupsOfUserResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/list_users.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,114 +17,121 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ListUsers(request *ListUsersRequest) (response *ListUsersResponse, err error) {
-	response = CreateListUsersResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateListUsersResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ListUsersWithChan(request *ListUsersRequest) (<-chan *ListUsersResponse, <-chan error) {
-	responseChan := make(chan *ListUsersResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ListUsers(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ListUsersResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ListUsers(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ListUsersWithCallback(request *ListUsersRequest, callback func(response *ListUsersResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ListUsersResponse
-		var err error
-		defer close(result)
-		response, err = client.ListUsers(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ListUsersWithCallback(request *ListUsersRequest, callback func(response *ListUsersResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ListUsersResponse
+var err error
+defer close(result)
+response, err = client.ListUsers(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ListUsersRequest struct {
-	*requests.RpcRequest
-	InstanceId  string `position:"Query" name:"InstanceId"`
-	PageSize    string `position:"Query" name:"PageSize"`
-	PageNumber  string `position:"Query" name:"PageNumber"`
-	AccessKeyId string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                PageSize  string `position:"Query" name:"PageSize"`
+                PageNumber  string `position:"Query" name:"PageNumber"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type ListUsersResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
-	Users          struct {
-		TotalCount int `json:"TotalCount"`
-		PageNumber int `json:"PageNumber"`
-		PageSize   int `json:"PageSize"`
-		List       []struct {
-			UserId     string `json:"UserId"`
-			RamId      string `json:"RamId"`
-			InstanceId string `json:"InstanceId"`
-			Primary    bool   `json:"Primary"`
-			Detail     struct {
-				LoginName   string `json:"LoginName"`
-				DisplayName string `json:"DisplayName"`
-				Phone       string `json:"Phone"`
-				Email       string `json:"Email"`
-				Department  string `json:"Department"`
-			} `json:"Detail"`
-			Roles []struct {
-				RoleId          string `json:"RoleId"`
-				InstanceId      string `json:"InstanceId"`
-				RoleName        string `json:"RoleName"`
-				RoleDescription string `json:"RoleDescription"`
-			} `json:"Roles"`
-			SkillLevels []struct {
-				SkillLevelId string `json:"SkillLevelId"`
-				Level        int    `json:"Level"`
-				Skill        struct {
-					SkillGroupId          string `json:"SkillGroupId"`
-					InstanceId            string `json:"InstanceId"`
-					SkillGroupName        string `json:"SkillGroupName"`
-					SkillGroupDescription string `json:"SkillGroupDescription"`
-				} `json:"Skill"`
-			} `json:"SkillLevels"`
-		} `json:"List"`
-	} `json:"Users"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+            Users struct {
+            TotalCount     int `json:"TotalCount" xml:"TotalCount"`
+            PageNumber     int `json:"PageNumber" xml:"PageNumber"`
+            PageSize     int `json:"PageSize" xml:"PageSize"`
+                List struct {
+                    User []struct {
+            UserId     string `json:"UserId" xml:"UserId"`
+            RamId     string `json:"RamId" xml:"RamId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            Primary     bool `json:"Primary" xml:"Primary"`
+            Detail struct {
+            LoginName     string `json:"LoginName" xml:"LoginName"`
+            DisplayName     string `json:"DisplayName" xml:"DisplayName"`
+            Phone     string `json:"Phone" xml:"Phone"`
+            Email     string `json:"Email" xml:"Email"`
+            Department     string `json:"Department" xml:"Department"`
+            }  `json:"Detail" xml:"Detail"`
+                Roles struct {
+                    Role []struct {
+            RoleId     string `json:"RoleId" xml:"RoleId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            RoleName     string `json:"RoleName" xml:"RoleName"`
+            RoleDescription     string `json:"RoleDescription" xml:"RoleDescription"`
+                    }   `json:"Role" xml:"Role"`
+                } `json:"Roles" xml:"Roles"`
+                SkillLevels struct {
+                    SkillLevel []struct {
+            SkillLevelId     string `json:"SkillLevelId" xml:"SkillLevelId"`
+            Level     int `json:"Level" xml:"Level"`
+            Skill struct {
+            SkillGroupId     string `json:"SkillGroupId" xml:"SkillGroupId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            SkillGroupName     string `json:"SkillGroupName" xml:"SkillGroupName"`
+            SkillGroupDescription     string `json:"SkillGroupDescription" xml:"SkillGroupDescription"`
+            }  `json:"Skill" xml:"Skill"`
+                    }   `json:"SkillLevel" xml:"SkillLevel"`
+                } `json:"SkillLevels" xml:"SkillLevels"`
+                    }   `json:"User" xml:"User"`
+                } `json:"List" xml:"List"`
+            }  `json:"Users" xml:"Users"`
 }
 
 func CreateListUsersRequest() (request *ListUsersRequest) {
-	request = &ListUsersRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "ListUsers", "", "")
-	return
+request = &ListUsersRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "ListUsers", "", "")
+return
 }
 
 func CreateListUsersResponse() (response *ListUsersResponse) {
-	response = &ListUsersResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ListUsersResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/list_users_of_skill_group.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,120 +17,129 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ListUsersOfSkillGroup(request *ListUsersOfSkillGroupRequest) (response *ListUsersOfSkillGroupResponse, err error) {
-	response = CreateListUsersOfSkillGroupResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateListUsersOfSkillGroupResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ListUsersOfSkillGroupWithChan(request *ListUsersOfSkillGroupRequest) (<-chan *ListUsersOfSkillGroupResponse, <-chan error) {
-	responseChan := make(chan *ListUsersOfSkillGroupResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ListUsersOfSkillGroup(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ListUsersOfSkillGroupResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ListUsersOfSkillGroup(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ListUsersOfSkillGroupWithCallback(request *ListUsersOfSkillGroupRequest, callback func(response *ListUsersOfSkillGroupResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ListUsersOfSkillGroupResponse
-		var err error
-		defer close(result)
-		response, err = client.ListUsersOfSkillGroup(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ListUsersOfSkillGroupWithCallback(request *ListUsersOfSkillGroupRequest, callback func(response *ListUsersOfSkillGroupResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ListUsersOfSkillGroupResponse
+var err error
+defer close(result)
+response, err = client.ListUsersOfSkillGroup(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ListUsersOfSkillGroupRequest struct {
-	*requests.RpcRequest
-	InstanceId   string `position:"Query" name:"InstanceId"`
-	SkillGroupId string `position:"Query" name:"SkillGroupId"`
-	PageSize     string `position:"Query" name:"PageSize"`
-	PageNumber   string `position:"Query" name:"PageNumber"`
-	AccessKeyId  string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                PageSize  string `position:"Query" name:"PageSize"`
+                PageNumber  string `position:"Query" name:"PageNumber"`
+                SkillGroupId  string `position:"Query" name:"SkillGroupId"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type ListUsersOfSkillGroupResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
-	Users          struct {
-		TotalCount int `json:"TotalCount"`
-		PageNumber int `json:"PageNumber"`
-		PageSize   int `json:"PageSize"`
-		List       []struct {
-			UserId     string `json:"UserId"`
-			RamId      string `json:"RamId"`
-			InstanceId string `json:"InstanceId"`
-			Detail     struct {
-				LoginName   string `json:"LoginName"`
-				DisplayName string `json:"DisplayName"`
-				Phone       string `json:"Phone"`
-				Email       string `json:"Email"`
-				Department  string `json:"Department"`
-			} `json:"Detail"`
-			Roles []struct {
-				RoleId          string `json:"RoleId"`
-				InstanceId      string `json:"InstanceId"`
-				RoleName        string `json:"RoleName"`
-				RoleDescription string `json:"RoleDescription"`
-				UserCount       int    `json:"UserCount"`
-				Privileges      []struct {
-					PrivilegeId          string `json:"PrivilegeId"`
-					PrivilegeName        string `json:"PrivilegeName"`
-					PrivilegeDescription string `json:"PrivilegeDescription"`
-				} `json:"Privileges"`
-			} `json:"Roles"`
-			SkillLevels []struct {
-				SkillLevelId string `json:"SkillLevelId"`
-				Level        int    `json:"Level"`
-				Skill        struct {
-					SkillGroupId          string `json:"SkillGroupId"`
-					InstanceId            string `json:"InstanceId"`
-					SkillGroupName        string `json:"SkillGroupName"`
-					SkillGroupDescription string `json:"SkillGroupDescription"`
-				} `json:"Skill"`
-			} `json:"SkillLevels"`
-		} `json:"List"`
-	} `json:"Users"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+            Users struct {
+            TotalCount     int `json:"TotalCount" xml:"TotalCount"`
+            PageNumber     int `json:"PageNumber" xml:"PageNumber"`
+            PageSize     int `json:"PageSize" xml:"PageSize"`
+                List struct {
+                    User []struct {
+            UserId     string `json:"UserId" xml:"UserId"`
+            RamId     string `json:"RamId" xml:"RamId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            Detail struct {
+            LoginName     string `json:"LoginName" xml:"LoginName"`
+            DisplayName     string `json:"DisplayName" xml:"DisplayName"`
+            Phone     string `json:"Phone" xml:"Phone"`
+            Email     string `json:"Email" xml:"Email"`
+            Department     string `json:"Department" xml:"Department"`
+            }  `json:"Detail" xml:"Detail"`
+                Roles struct {
+                    Role []struct {
+            RoleId     string `json:"RoleId" xml:"RoleId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            RoleName     string `json:"RoleName" xml:"RoleName"`
+            RoleDescription     string `json:"RoleDescription" xml:"RoleDescription"`
+            UserCount     int `json:"UserCount" xml:"UserCount"`
+                Privileges struct {
+                    Privilege []struct {
+            PrivilegeId     string `json:"PrivilegeId" xml:"PrivilegeId"`
+            PrivilegeName     string `json:"PrivilegeName" xml:"PrivilegeName"`
+            PrivilegeDescription     string `json:"PrivilegeDescription" xml:"PrivilegeDescription"`
+                    }   `json:"Privilege" xml:"Privilege"`
+                } `json:"Privileges" xml:"Privileges"`
+                    }   `json:"Role" xml:"Role"`
+                } `json:"Roles" xml:"Roles"`
+                SkillLevels struct {
+                    SkillLevel []struct {
+            SkillLevelId     string `json:"SkillLevelId" xml:"SkillLevelId"`
+            Level     int `json:"Level" xml:"Level"`
+            Skill struct {
+            SkillGroupId     string `json:"SkillGroupId" xml:"SkillGroupId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            SkillGroupName     string `json:"SkillGroupName" xml:"SkillGroupName"`
+            SkillGroupDescription     string `json:"SkillGroupDescription" xml:"SkillGroupDescription"`
+            }  `json:"Skill" xml:"Skill"`
+                    }   `json:"SkillLevel" xml:"SkillLevel"`
+                } `json:"SkillLevels" xml:"SkillLevels"`
+                    }   `json:"User" xml:"User"`
+                } `json:"List" xml:"List"`
+            }  `json:"Users" xml:"Users"`
 }
 
 func CreateListUsersOfSkillGroupRequest() (request *ListUsersOfSkillGroupRequest) {
-	request = &ListUsersOfSkillGroupRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "ListUsersOfSkillGroup", "", "")
-	return
+request = &ListUsersOfSkillGroupRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "ListUsersOfSkillGroup", "", "")
+return
 }
 
 func CreateListUsersOfSkillGroupResponse() (response *ListUsersOfSkillGroupResponse) {
-	response = &ListUsersOfSkillGroupResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ListUsersOfSkillGroupResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/modify_phone_number.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,99 +17,100 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ModifyPhoneNumber(request *ModifyPhoneNumberRequest) (response *ModifyPhoneNumberResponse, err error) {
-	response = CreateModifyPhoneNumberResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateModifyPhoneNumberResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ModifyPhoneNumberWithChan(request *ModifyPhoneNumberRequest) (<-chan *ModifyPhoneNumberResponse, <-chan error) {
-	responseChan := make(chan *ModifyPhoneNumberResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ModifyPhoneNumber(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ModifyPhoneNumberResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ModifyPhoneNumber(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ModifyPhoneNumberWithCallback(request *ModifyPhoneNumberRequest, callback func(response *ModifyPhoneNumberResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ModifyPhoneNumberResponse
-		var err error
-		defer close(result)
-		response, err = client.ModifyPhoneNumber(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ModifyPhoneNumberWithCallback(request *ModifyPhoneNumberRequest, callback func(response *ModifyPhoneNumberResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ModifyPhoneNumberResponse
+var err error
+defer close(result)
+response, err = client.ModifyPhoneNumber(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ModifyPhoneNumberRequest struct {
-	*requests.RpcRequest
-	ContactFlowId string `position:"Query" name:"ContactFlowId"`
-	InstanceId    string `position:"Query" name:"InstanceId"`
-	PhoneNumberId string `position:"Query" name:"PhoneNumberId"`
-	Usage         string `position:"Query" name:"Usage"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                PhoneNumberId  string `position:"Query" name:"PhoneNumberId"`
+                Usage  string `position:"Query" name:"Usage"`
+                ContactFlowId  string `position:"Query" name:"ContactFlowId"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type ModifyPhoneNumberResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
-	PhoneNumber    struct {
-		PhoneNumberId          string `json:"PhoneNumberId"`
-		InstanceId             string `json:"InstanceId"`
-		Number                 string `json:"Number"`
-		PhoneNumberDescription string `json:"PhoneNumberDescription"`
-		TestOnly               bool   `json:"TestOnly"`
-		RemainingTime          int    `json:"RemainingTime"`
-		AllowOutbound          bool   `json:"AllowOutbound"`
-		Usage                  string `json:"Usage"`
-		Trunks                 int    `json:"Trunks"`
-		ContactFlow            struct {
-			ContactFlowId          string `json:"ContactFlowId"`
-			InstanceId             string `json:"InstanceId"`
-			ContactFlowName        string `json:"ContactFlowName"`
-			ContactFlowDescription string `json:"ContactFlowDescription"`
-			Type                   string `json:"Type"`
-		} `json:"ContactFlow"`
-	} `json:"PhoneNumber"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+            PhoneNumber struct {
+            PhoneNumberId     string `json:"PhoneNumberId" xml:"PhoneNumberId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            Number     string `json:"Number" xml:"Number"`
+            PhoneNumberDescription     string `json:"PhoneNumberDescription" xml:"PhoneNumberDescription"`
+            TestOnly     bool `json:"TestOnly" xml:"TestOnly"`
+            RemainingTime     int `json:"RemainingTime" xml:"RemainingTime"`
+            AllowOutbound     bool `json:"AllowOutbound" xml:"AllowOutbound"`
+            Usage     string `json:"Usage" xml:"Usage"`
+            Trunks     int `json:"Trunks" xml:"Trunks"`
+            ContactFlow struct {
+            ContactFlowId     string `json:"ContactFlowId" xml:"ContactFlowId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            ContactFlowName     string `json:"ContactFlowName" xml:"ContactFlowName"`
+            ContactFlowDescription     string `json:"ContactFlowDescription" xml:"ContactFlowDescription"`
+            Type     string `json:"Type" xml:"Type"`
+            }  `json:"ContactFlow" xml:"ContactFlow"`
+            }  `json:"PhoneNumber" xml:"PhoneNumber"`
 }
 
 func CreateModifyPhoneNumberRequest() (request *ModifyPhoneNumberRequest) {
-	request = &ModifyPhoneNumberRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "ModifyPhoneNumber", "", "")
-	return
+request = &ModifyPhoneNumberRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "ModifyPhoneNumber", "", "")
+return
 }
 
 func CreateModifyPhoneNumberResponse() (response *ModifyPhoneNumberResponse) {
-	response = &ModifyPhoneNumberResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ModifyPhoneNumberResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/modify_skill_group.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,84 +17,85 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ModifySkillGroup(request *ModifySkillGroupRequest) (response *ModifySkillGroupResponse, err error) {
-	response = CreateModifySkillGroupResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateModifySkillGroupResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ModifySkillGroupWithChan(request *ModifySkillGroupRequest) (<-chan *ModifySkillGroupResponse, <-chan error) {
-	responseChan := make(chan *ModifySkillGroupResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ModifySkillGroup(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ModifySkillGroupResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ModifySkillGroup(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ModifySkillGroupWithCallback(request *ModifySkillGroupRequest, callback func(response *ModifySkillGroupResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ModifySkillGroupResponse
-		var err error
-		defer close(result)
-		response, err = client.ModifySkillGroup(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ModifySkillGroupWithCallback(request *ModifySkillGroupRequest, callback func(response *ModifySkillGroupResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ModifySkillGroupResponse
+var err error
+defer close(result)
+response, err = client.ModifySkillGroup(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ModifySkillGroupRequest struct {
-	*requests.RpcRequest
-	SkillLevel            *[]string `position:"Query" name:"SkillLevel"  type:"Repeated"`
-	InstanceId            string    `position:"Query" name:"InstanceId"`
-	OutboundPhoneNumberId *[]string `position:"Query" name:"OutboundPhoneNumberId"  type:"Repeated"`
-	SkillGroupId          string    `position:"Query" name:"SkillGroupId"`
-	Name                  string    `position:"Query" name:"Name"`
-	Description           string    `position:"Query" name:"Description"`
-	UserId                *[]string `position:"Query" name:"UserId"  type:"Repeated"`
-	AccessKeyId           string    `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                SkillLevel  *[]string `position:"Query" name:"SkillLevel"  type:"Repeated"`
+                Description  string `position:"Query" name:"Description"`
+                SkillGroupId  string `position:"Query" name:"SkillGroupId"`
+                Name  string `position:"Query" name:"Name"`
+                UserId  *[]string `position:"Query" name:"UserId"  type:"Repeated"`
+                OutboundPhoneNumberId  *[]string `position:"Query" name:"OutboundPhoneNumberId"  type:"Repeated"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type ModifySkillGroupResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
 }
 
 func CreateModifySkillGroupRequest() (request *ModifySkillGroupRequest) {
-	request = &ModifySkillGroupRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "ModifySkillGroup", "", "")
-	return
+request = &ModifySkillGroupRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "ModifySkillGroup", "", "")
+return
 }
 
 func CreateModifySkillGroupResponse() (response *ModifySkillGroupResponse) {
-	response = &ModifySkillGroupResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ModifySkillGroupResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/modify_user.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,85 +17,86 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ModifyUser(request *ModifyUserRequest) (response *ModifyUserResponse, err error) {
-	response = CreateModifyUserResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateModifyUserResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ModifyUserWithChan(request *ModifyUserRequest) (<-chan *ModifyUserResponse, <-chan error) {
-	responseChan := make(chan *ModifyUserResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ModifyUser(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ModifyUserResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ModifyUser(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ModifyUserWithCallback(request *ModifyUserRequest, callback func(response *ModifyUserResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ModifyUserResponse
-		var err error
-		defer close(result)
-		response, err = client.ModifyUser(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ModifyUserWithCallback(request *ModifyUserRequest, callback func(response *ModifyUserResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ModifyUserResponse
+var err error
+defer close(result)
+response, err = client.ModifyUser(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ModifyUserRequest struct {
-	*requests.RpcRequest
-	SkillLevel   *[]string `position:"Query" name:"SkillLevel"  type:"Repeated"`
-	InstanceId   string    `position:"Query" name:"InstanceId"`
-	Phone        string    `position:"Query" name:"Phone"`
-	RoleId       *[]string `position:"Query" name:"RoleId"  type:"Repeated"`
-	DisplayName  string    `position:"Query" name:"DisplayName"`
-	SkillGroupId *[]string `position:"Query" name:"SkillGroupId"  type:"Repeated"`
-	UserId       string    `position:"Query" name:"UserId"`
-	Email        string    `position:"Query" name:"Email"`
-	AccessKeyId  string    `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                Phone  string `position:"Query" name:"Phone"`
+                SkillLevel  *[]string `position:"Query" name:"SkillLevel"  type:"Repeated"`
+                RoleId  *[]string `position:"Query" name:"RoleId"  type:"Repeated"`
+                Email  string `position:"Query" name:"Email"`
+                SkillGroupId  *[]string `position:"Query" name:"SkillGroupId"  type:"Repeated"`
+                UserId  string `position:"Query" name:"UserId"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
+                DisplayName  string `position:"Query" name:"DisplayName"`
 }
 
+
 type ModifyUserResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
 }
 
 func CreateModifyUserRequest() (request *ModifyUserRequest) {
-	request = &ModifyUserRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "ModifyUser", "", "")
-	return
+request = &ModifyUserRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "ModifyUser", "", "")
+return
 }
 
 func CreateModifyUserResponse() (response *ModifyUserResponse) {
-	response = &ModifyUserResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ModifyUserResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/refresh_token.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,82 +17,83 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) RefreshToken(request *RefreshTokenRequest) (response *RefreshTokenResponse, err error) {
-	response = CreateRefreshTokenResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateRefreshTokenResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) RefreshTokenWithChan(request *RefreshTokenRequest) (<-chan *RefreshTokenResponse, <-chan error) {
-	responseChan := make(chan *RefreshTokenResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.RefreshToken(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *RefreshTokenResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.RefreshToken(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) RefreshTokenWithCallback(request *RefreshTokenRequest, callback func(response *RefreshTokenResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *RefreshTokenResponse
-		var err error
-		defer close(result)
-		response, err = client.RefreshToken(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) RefreshTokenWithCallback(request *RefreshTokenRequest, callback func(response *RefreshTokenResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *RefreshTokenResponse
+var err error
+defer close(result)
+response, err = client.RefreshToken(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type RefreshTokenRequest struct {
-	*requests.RpcRequest
-	InstanceId  string `position:"Query" name:"InstanceId"`
-	AccessKeyId string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type RefreshTokenResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
-	Token          struct {
-		Signature string `json:"Signature"`
-		SignData  string `json:"SignData"`
-	} `json:"Token"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+            Token struct {
+            Signature     string `json:"Signature" xml:"Signature"`
+            SignData     string `json:"SignData" xml:"SignData"`
+            }  `json:"Token" xml:"Token"`
 }
 
 func CreateRefreshTokenRequest() (request *RefreshTokenRequest) {
-	request = &RefreshTokenRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "RefreshToken", "", "")
-	return
+request = &RefreshTokenRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "RefreshToken", "", "")
+return
 }
 
 func CreateRefreshTokenResponse() (response *RefreshTokenResponse) {
-	response = &RefreshTokenResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &RefreshTokenResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/remove_phone_number.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,79 +17,80 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) RemovePhoneNumber(request *RemovePhoneNumberRequest) (response *RemovePhoneNumberResponse, err error) {
-	response = CreateRemovePhoneNumberResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateRemovePhoneNumberResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) RemovePhoneNumberWithChan(request *RemovePhoneNumberRequest) (<-chan *RemovePhoneNumberResponse, <-chan error) {
-	responseChan := make(chan *RemovePhoneNumberResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.RemovePhoneNumber(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *RemovePhoneNumberResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.RemovePhoneNumber(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) RemovePhoneNumberWithCallback(request *RemovePhoneNumberRequest, callback func(response *RemovePhoneNumberResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *RemovePhoneNumberResponse
-		var err error
-		defer close(result)
-		response, err = client.RemovePhoneNumber(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) RemovePhoneNumberWithCallback(request *RemovePhoneNumberRequest, callback func(response *RemovePhoneNumberResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *RemovePhoneNumberResponse
+var err error
+defer close(result)
+response, err = client.RemovePhoneNumber(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type RemovePhoneNumberRequest struct {
-	*requests.RpcRequest
-	InstanceId    string `position:"Query" name:"InstanceId"`
-	PhoneNumberId string `position:"Query" name:"PhoneNumberId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                PhoneNumberId  string `position:"Query" name:"PhoneNumberId"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type RemovePhoneNumberResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
 }
 
 func CreateRemovePhoneNumberRequest() (request *RemovePhoneNumberRequest) {
-	request = &RemovePhoneNumberRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "RemovePhoneNumber", "", "")
-	return
+request = &RemovePhoneNumberRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "RemovePhoneNumber", "", "")
+return
 }
 
 func CreateRemovePhoneNumberResponse() (response *RemovePhoneNumberResponse) {
-	response = &RemovePhoneNumberResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &RemovePhoneNumberResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/remove_users.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,79 +17,80 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) RemoveUsers(request *RemoveUsersRequest) (response *RemoveUsersResponse, err error) {
-	response = CreateRemoveUsersResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateRemoveUsersResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) RemoveUsersWithChan(request *RemoveUsersRequest) (<-chan *RemoveUsersResponse, <-chan error) {
-	responseChan := make(chan *RemoveUsersResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.RemoveUsers(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *RemoveUsersResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.RemoveUsers(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) RemoveUsersWithCallback(request *RemoveUsersRequest, callback func(response *RemoveUsersResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *RemoveUsersResponse
-		var err error
-		defer close(result)
-		response, err = client.RemoveUsers(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) RemoveUsersWithCallback(request *RemoveUsersRequest, callback func(response *RemoveUsersResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *RemoveUsersResponse
+var err error
+defer close(result)
+response, err = client.RemoveUsers(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type RemoveUsersRequest struct {
-	*requests.RpcRequest
-	InstanceId  string    `position:"Query" name:"InstanceId"`
-	UserId      *[]string `position:"Query" name:"UserId"  type:"Repeated"`
-	AccessKeyId string    `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                UserId  *[]string `position:"Query" name:"UserId"  type:"Repeated"`
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type RemoveUsersResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
 }
 
 func CreateRemoveUsersRequest() (request *RemoveUsersRequest) {
-	request = &RemoveUsersRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "RemoveUsers", "", "")
-	return
+request = &RemoveUsersRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "RemoveUsers", "", "")
+return
 }
 
 func CreateRemoveUsersResponse() (response *RemoveUsersResponse) {
-	response = &RemoveUsersResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &RemoveUsersResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/ccc/request_login_info.go

@@ -1,3 +1,4 @@
+
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,89 +17,90 @@ package ccc
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) RequestLoginInfo(request *RequestLoginInfoRequest) (response *RequestLoginInfoResponse, err error) {
-	response = CreateRequestLoginInfoResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateRequestLoginInfoResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) RequestLoginInfoWithChan(request *RequestLoginInfoRequest) (<-chan *RequestLoginInfoResponse, <-chan error) {
-	responseChan := make(chan *RequestLoginInfoResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.RequestLoginInfo(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *RequestLoginInfoResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.RequestLoginInfo(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) RequestLoginInfoWithCallback(request *RequestLoginInfoRequest, callback func(response *RequestLoginInfoResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *RequestLoginInfoResponse
-		var err error
-		defer close(result)
-		response, err = client.RequestLoginInfo(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) RequestLoginInfoWithCallback(request *RequestLoginInfoRequest, callback func(response *RequestLoginInfoResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *RequestLoginInfoResponse
+var err error
+defer close(result)
+response, err = client.RequestLoginInfo(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type RequestLoginInfoRequest struct {
-	*requests.RpcRequest
-	InstanceId  string `position:"Query" name:"InstanceId"`
-	AccessKeyId string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
+
 type RequestLoginInfoResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	Success        bool   `json:"Success"`
-	Code           string `json:"Code"`
-	Message        string `json:"Message"`
-	HttpStatusCode int    `json:"HttpStatusCode"`
-	LoginInfo      struct {
-		UserName       string `json:"UserName"`
-		DisplayName    string `json:"DisplayName"`
-		Region         string `json:"Region"`
-		WebRtcUrl      string `json:"WebRtcUrl"`
-		AgentServerUrl string `json:"AgentServerUrl"`
-		Extension      string `json:"Extension"`
-		TenantId       string `json:"TenantId"`
-		Signature      string `json:"Signature"`
-		SignData       string `json:"SignData"`
-	} `json:"LoginInfo"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            Success     bool `json:"Success" xml:"Success"`
+            Code     string `json:"Code" xml:"Code"`
+            Message     string `json:"Message" xml:"Message"`
+            HttpStatusCode     int `json:"HttpStatusCode" xml:"HttpStatusCode"`
+            LoginInfo struct {
+            UserName     string `json:"UserName" xml:"UserName"`
+            DisplayName     string `json:"DisplayName" xml:"DisplayName"`
+            Region     string `json:"Region" xml:"Region"`
+            WebRtcUrl     string `json:"WebRtcUrl" xml:"WebRtcUrl"`
+            AgentServerUrl     string `json:"AgentServerUrl" xml:"AgentServerUrl"`
+            Extension     string `json:"Extension" xml:"Extension"`
+            TenantId     string `json:"TenantId" xml:"TenantId"`
+            Signature     string `json:"Signature" xml:"Signature"`
+            SignData     string `json:"SignData" xml:"SignData"`
+            }  `json:"LoginInfo" xml:"LoginInfo"`
 }
 
 func CreateRequestLoginInfoRequest() (request *RequestLoginInfoRequest) {
-	request = &RequestLoginInfoRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("CCC", "2017-07-05", "RequestLoginInfo", "", "")
-	return
+request = &RequestLoginInfoRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("CCC", "2017-07-05", "RequestLoginInfo", "", "")
+return
 }
 
 func CreateRequestLoginInfoResponse() (response *RequestLoginInfoResponse) {
-	response = &RequestLoginInfoResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &RequestLoginInfoResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/add_cdn_domain.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,89 +17,89 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddCdnDomain(request *AddCdnDomainRequest) (response *AddCdnDomainResponse, err error) {
-	response = CreateAddCdnDomainResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateAddCdnDomainResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) AddCdnDomainWithChan(request *AddCdnDomainRequest) (<-chan *AddCdnDomainResponse, <-chan error) {
-	responseChan := make(chan *AddCdnDomainResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.AddCdnDomain(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *AddCdnDomainResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.AddCdnDomain(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) AddCdnDomainWithCallback(request *AddCdnDomainRequest, callback func(response *AddCdnDomainResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *AddCdnDomainResponse
-		var err error
-		defer close(result)
-		response, err = client.AddCdnDomain(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) AddCdnDomainWithCallback(request *AddCdnDomainRequest, callback func(response *AddCdnDomainResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *AddCdnDomainResponse
+var err error
+defer close(result)
+response, err = client.AddCdnDomain(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type AddCdnDomainRequest struct {
-	*requests.RpcRequest
-	TopLevelDomain  string `position:"Query" name:"TopLevelDomain"`
-	Sources         string `position:"Query" name:"Sources"`
-	OwnerAccount    string `position:"Query" name:"OwnerAccount"`
-	DomainName      string `position:"Query" name:"DomainName"`
-	LiveType        string `position:"Query" name:"LiveType"`
-	OwnerId         string `position:"Query" name:"OwnerId"`
-	AccessKeyId     string `position:"Query" name:"AccessKeyId"`
-	ResourceGroupId string `position:"Query" name:"ResourceGroupId"`
-	SourcePort      string `position:"Query" name:"SourcePort"`
-	Priorities      string `position:"Query" name:"Priorities"`
-	SecurityToken   string `position:"Query" name:"SecurityToken"`
-	CdnType         string `position:"Query" name:"CdnType"`
-	Scope           string `position:"Query" name:"Scope"`
-	Action          string `position:"Query" name:"Action"`
-	SourceType      string `position:"Query" name:"SourceType"`
-	CheckUrl        string `position:"Query" name:"CheckUrl"`
-	Region          string `position:"Query" name:"Region"`
+*requests.RpcRequest
+                Region  string `position:"Query" name:"Region"`
+                CheckUrl  string `position:"Query" name:"CheckUrl"`
+                TopLevelDomain  string `position:"Query" name:"TopLevelDomain"`
+                Scope  string `position:"Query" name:"Scope"`
+                ResourceGroupId  string `position:"Query" name:"ResourceGroupId"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                Sources  string `position:"Query" name:"Sources"`
+                SourcePort  string `position:"Query" name:"SourcePort"`
+                Priorities  string `position:"Query" name:"Priorities"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                LiveType  string `position:"Query" name:"LiveType"`
+                CdnType  string `position:"Query" name:"CdnType"`
+                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
+                SourceType  string `position:"Query" name:"SourceType"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type AddCdnDomainResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateAddCdnDomainRequest() (request *AddCdnDomainRequest) {
-	request = &AddCdnDomainRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "AddCdnDomain", "", "")
-	return
+request = &AddCdnDomainRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "AddCdnDomain", "", "")
+return
 }
 
 func CreateAddCdnDomainResponse() (response *AddCdnDomainResponse) {
-	response = &AddCdnDomainResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &AddCdnDomainResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/add_live_app_record_config.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,81 +17,81 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddLiveAppRecordConfig(request *AddLiveAppRecordConfigRequest) (response *AddLiveAppRecordConfigResponse, err error) {
-	response = CreateAddLiveAppRecordConfigResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateAddLiveAppRecordConfigResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) AddLiveAppRecordConfigWithChan(request *AddLiveAppRecordConfigRequest) (<-chan *AddLiveAppRecordConfigResponse, <-chan error) {
-	responseChan := make(chan *AddLiveAppRecordConfigResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.AddLiveAppRecordConfig(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *AddLiveAppRecordConfigResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.AddLiveAppRecordConfig(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) AddLiveAppRecordConfigWithCallback(request *AddLiveAppRecordConfigRequest, callback func(response *AddLiveAppRecordConfigResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *AddLiveAppRecordConfigResponse
-		var err error
-		defer close(result)
-		response, err = client.AddLiveAppRecordConfig(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) AddLiveAppRecordConfigWithCallback(request *AddLiveAppRecordConfigRequest, callback func(response *AddLiveAppRecordConfigResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *AddLiveAppRecordConfigResponse
+var err error
+defer close(result)
+response, err = client.AddLiveAppRecordConfig(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type AddLiveAppRecordConfigRequest struct {
-	*requests.RpcRequest
-	OssBucket       string `position:"Query" name:"OssBucket"`
-	AppName         string `position:"Query" name:"AppName"`
-	SecurityToken   string `position:"Query" name:"SecurityToken"`
-	DomainName      string `position:"Query" name:"DomainName"`
-	OssEndpoint     string `position:"Query" name:"OssEndpoint"`
-	OssObjectPrefix string `position:"Query" name:"OssObjectPrefix"`
-	Action          string `position:"Query" name:"Action"`
-	OwnerId         string `position:"Query" name:"OwnerId"`
-	AccessKeyId     string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                OssBucket  string `position:"Query" name:"OssBucket"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                OssEndpoint  string `position:"Query" name:"OssEndpoint"`
+                AppName  string `position:"Query" name:"AppName"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                OssObjectPrefix  string `position:"Query" name:"OssObjectPrefix"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type AddLiveAppRecordConfigResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateAddLiveAppRecordConfigRequest() (request *AddLiveAppRecordConfigRequest) {
-	request = &AddLiveAppRecordConfigRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveAppRecordConfig", "", "")
-	return
+request = &AddLiveAppRecordConfigRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveAppRecordConfig", "", "")
+return
 }
 
 func CreateAddLiveAppRecordConfigResponse() (response *AddLiveAppRecordConfigResponse) {
-	response = &AddLiveAppRecordConfigResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &AddLiveAppRecordConfigResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/add_live_app_snapshot_config.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,83 +17,83 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddLiveAppSnapshotConfig(request *AddLiveAppSnapshotConfigRequest) (response *AddLiveAppSnapshotConfigResponse, err error) {
-	response = CreateAddLiveAppSnapshotConfigResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateAddLiveAppSnapshotConfigResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) AddLiveAppSnapshotConfigWithChan(request *AddLiveAppSnapshotConfigRequest) (<-chan *AddLiveAppSnapshotConfigResponse, <-chan error) {
-	responseChan := make(chan *AddLiveAppSnapshotConfigResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.AddLiveAppSnapshotConfig(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *AddLiveAppSnapshotConfigResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.AddLiveAppSnapshotConfig(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) AddLiveAppSnapshotConfigWithCallback(request *AddLiveAppSnapshotConfigRequest, callback func(response *AddLiveAppSnapshotConfigResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *AddLiveAppSnapshotConfigResponse
-		var err error
-		defer close(result)
-		response, err = client.AddLiveAppSnapshotConfig(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) AddLiveAppSnapshotConfigWithCallback(request *AddLiveAppSnapshotConfigRequest, callback func(response *AddLiveAppSnapshotConfigResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *AddLiveAppSnapshotConfigResponse
+var err error
+defer close(result)
+response, err = client.AddLiveAppSnapshotConfig(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type AddLiveAppSnapshotConfigRequest struct {
-	*requests.RpcRequest
-	TimeInterval       string `position:"Query" name:"TimeInterval"`
-	OssBucket          string `position:"Query" name:"OssBucket"`
-	AppName            string `position:"Query" name:"AppName"`
-	SecurityToken      string `position:"Query" name:"SecurityToken"`
-	DomainName         string `position:"Query" name:"DomainName"`
-	OssEndpoint        string `position:"Query" name:"OssEndpoint"`
-	Action             string `position:"Query" name:"Action"`
-	SequenceOssObject  string `position:"Query" name:"SequenceOssObject"`
-	OverwriteOssObject string `position:"Query" name:"OverwriteOssObject"`
-	OwnerId            string `position:"Query" name:"OwnerId"`
-	AccessKeyId        string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                TimeInterval  string `position:"Query" name:"TimeInterval"`
+                OssBucket  string `position:"Query" name:"OssBucket"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                OssEndpoint  string `position:"Query" name:"OssEndpoint"`
+                AppName  string `position:"Query" name:"AppName"`
+                SequenceOssObject  string `position:"Query" name:"SequenceOssObject"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
+                OverwriteOssObject  string `position:"Query" name:"OverwriteOssObject"`
 }
 
+
 type AddLiveAppSnapshotConfigResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateAddLiveAppSnapshotConfigRequest() (request *AddLiveAppSnapshotConfigRequest) {
-	request = &AddLiveAppSnapshotConfigRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveAppSnapshotConfig", "", "")
-	return
+request = &AddLiveAppSnapshotConfigRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveAppSnapshotConfig", "", "")
+return
 }
 
 func CreateAddLiveAppSnapshotConfigResponse() (response *AddLiveAppSnapshotConfigResponse) {
-	response = &AddLiveAppSnapshotConfigResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &AddLiveAppSnapshotConfigResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/add_live_domain_mapping.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,78 +17,78 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddLiveDomainMapping(request *AddLiveDomainMappingRequest) (response *AddLiveDomainMappingResponse, err error) {
-	response = CreateAddLiveDomainMappingResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateAddLiveDomainMappingResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) AddLiveDomainMappingWithChan(request *AddLiveDomainMappingRequest) (<-chan *AddLiveDomainMappingResponse, <-chan error) {
-	responseChan := make(chan *AddLiveDomainMappingResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.AddLiveDomainMapping(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *AddLiveDomainMappingResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.AddLiveDomainMapping(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) AddLiveDomainMappingWithCallback(request *AddLiveDomainMappingRequest, callback func(response *AddLiveDomainMappingResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *AddLiveDomainMappingResponse
-		var err error
-		defer close(result)
-		response, err = client.AddLiveDomainMapping(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) AddLiveDomainMappingWithCallback(request *AddLiveDomainMappingRequest, callback func(response *AddLiveDomainMappingResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *AddLiveDomainMappingResponse
+var err error
+defer close(result)
+response, err = client.AddLiveDomainMapping(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type AddLiveDomainMappingRequest struct {
-	*requests.RpcRequest
-	PullDomain    string `position:"Query" name:"PullDomain"`
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	PushDomain    string `position:"Query" name:"PushDomain"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                PullDomain  string `position:"Query" name:"PullDomain"`
+                PushDomain  string `position:"Query" name:"PushDomain"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type AddLiveDomainMappingResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateAddLiveDomainMappingRequest() (request *AddLiveDomainMappingRequest) {
-	request = &AddLiveDomainMappingRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveDomainMapping", "", "")
-	return
+request = &AddLiveDomainMappingRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveDomainMapping", "", "")
+return
 }
 
 func CreateAddLiveDomainMappingResponse() (response *AddLiveDomainMappingResponse) {
-	response = &AddLiveDomainMappingResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &AddLiveDomainMappingResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/add_live_pull_stream_info.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,82 +17,82 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddLivePullStreamInfo(request *AddLivePullStreamInfoRequest) (response *AddLivePullStreamInfoResponse, err error) {
-	response = CreateAddLivePullStreamInfoResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateAddLivePullStreamInfoResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) AddLivePullStreamInfoWithChan(request *AddLivePullStreamInfoRequest) (<-chan *AddLivePullStreamInfoResponse, <-chan error) {
-	responseChan := make(chan *AddLivePullStreamInfoResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.AddLivePullStreamInfo(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *AddLivePullStreamInfoResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.AddLivePullStreamInfo(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) AddLivePullStreamInfoWithCallback(request *AddLivePullStreamInfoRequest, callback func(response *AddLivePullStreamInfoResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *AddLivePullStreamInfoResponse
-		var err error
-		defer close(result)
-		response, err = client.AddLivePullStreamInfo(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) AddLivePullStreamInfoWithCallback(request *AddLivePullStreamInfoRequest, callback func(response *AddLivePullStreamInfoResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *AddLivePullStreamInfoResponse
+var err error
+defer close(result)
+response, err = client.AddLivePullStreamInfo(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type AddLivePullStreamInfoRequest struct {
-	*requests.RpcRequest
-	SourceUrl     string `position:"Query" name:"SourceUrl"`
-	AppName       string `position:"Query" name:"AppName"`
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	DomainName    string `position:"Query" name:"DomainName"`
-	Action        string `position:"Query" name:"Action"`
-	EndTime       string `position:"Query" name:"EndTime"`
-	StartTime     string `position:"Query" name:"StartTime"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	StreamName    string `position:"Query" name:"StreamName"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                EndTime  string `position:"Query" name:"EndTime"`
+                StreamName  string `position:"Query" name:"StreamName"`
+                StartTime  string `position:"Query" name:"StartTime"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                SourceUrl  string `position:"Query" name:"SourceUrl"`
+                AppName  string `position:"Query" name:"AppName"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type AddLivePullStreamInfoResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateAddLivePullStreamInfoRequest() (request *AddLivePullStreamInfoRequest) {
-	request = &AddLivePullStreamInfoRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "AddLivePullStreamInfo", "", "")
-	return
+request = &AddLivePullStreamInfoRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "AddLivePullStreamInfo", "", "")
+return
 }
 
 func CreateAddLivePullStreamInfoResponse() (response *AddLivePullStreamInfoResponse) {
-	response = &AddLivePullStreamInfoResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &AddLivePullStreamInfoResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/add_live_stream_transcode.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,82 +17,82 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddLiveStreamTranscode(request *AddLiveStreamTranscodeRequest) (response *AddLiveStreamTranscodeResponse, err error) {
-	response = CreateAddLiveStreamTranscodeResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateAddLiveStreamTranscodeResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) AddLiveStreamTranscodeWithChan(request *AddLiveStreamTranscodeRequest) (<-chan *AddLiveStreamTranscodeResponse, <-chan error) {
-	responseChan := make(chan *AddLiveStreamTranscodeResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.AddLiveStreamTranscode(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *AddLiveStreamTranscodeResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.AddLiveStreamTranscode(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) AddLiveStreamTranscodeWithCallback(request *AddLiveStreamTranscodeRequest, callback func(response *AddLiveStreamTranscodeResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *AddLiveStreamTranscodeResponse
-		var err error
-		defer close(result)
-		response, err = client.AddLiveStreamTranscode(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) AddLiveStreamTranscodeWithCallback(request *AddLiveStreamTranscodeRequest, callback func(response *AddLiveStreamTranscodeResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *AddLiveStreamTranscodeResponse
+var err error
+defer close(result)
+response, err = client.AddLiveStreamTranscode(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type AddLiveStreamTranscodeRequest struct {
-	*requests.RpcRequest
-	Template      string `position:"Query" name:"Template"`
-	App           string `position:"Query" name:"App"`
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	OwnerAccount  string `position:"Query" name:"OwnerAccount"`
-	Domain        string `position:"Query" name:"Domain"`
-	Record        string `position:"Query" name:"Record"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	Snapshot      string `position:"Query" name:"Snapshot"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                Template  string `position:"Query" name:"Template"`
+                App  string `position:"Query" name:"App"`
+                Record  string `position:"Query" name:"Record"`
+                Snapshot  string `position:"Query" name:"Snapshot"`
+                Domain  string `position:"Query" name:"Domain"`
+                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type AddLiveStreamTranscodeResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateAddLiveStreamTranscodeRequest() (request *AddLiveStreamTranscodeRequest) {
-	request = &AddLiveStreamTranscodeRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveStreamTranscode", "", "")
-	return
+request = &AddLiveStreamTranscodeRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveStreamTranscode", "", "")
+return
 }
 
 func CreateAddLiveStreamTranscodeResponse() (response *AddLiveStreamTranscodeResponse) {
-	response = &AddLiveStreamTranscodeResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &AddLiveStreamTranscodeResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/batch_describe_domain_bps_data.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,90 +17,94 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) BatchDescribeDomainBpsData(request *BatchDescribeDomainBpsDataRequest) (response *BatchDescribeDomainBpsDataResponse, err error) {
-	response = CreateBatchDescribeDomainBpsDataResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateBatchDescribeDomainBpsDataResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) BatchDescribeDomainBpsDataWithChan(request *BatchDescribeDomainBpsDataRequest) (<-chan *BatchDescribeDomainBpsDataResponse, <-chan error) {
-	responseChan := make(chan *BatchDescribeDomainBpsDataResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.BatchDescribeDomainBpsData(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *BatchDescribeDomainBpsDataResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.BatchDescribeDomainBpsData(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) BatchDescribeDomainBpsDataWithCallback(request *BatchDescribeDomainBpsDataRequest, callback func(response *BatchDescribeDomainBpsDataResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *BatchDescribeDomainBpsDataResponse
-		var err error
-		defer close(result)
-		response, err = client.BatchDescribeDomainBpsData(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) BatchDescribeDomainBpsDataWithCallback(request *BatchDescribeDomainBpsDataRequest, callback func(response *BatchDescribeDomainBpsDataResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *BatchDescribeDomainBpsDataResponse
+var err error
+defer close(result)
+response, err = client.BatchDescribeDomainBpsData(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type BatchDescribeDomainBpsDataRequest struct {
-	*requests.RpcRequest
-	StartTime     string `position:"Query" name:"StartTime"`
-	PageNumber    string `position:"Query" name:"PageNumber"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	PageSize      string `position:"Query" name:"PageSize"`
-	Action        string `position:"Query" name:"Action"`
-	DomainName    string `position:"Query" name:"DomainName"`
-	EndTime       string `position:"Query" name:"EndTime"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	Version       string `position:"Query" name:"Version"`
+*requests.RpcRequest
+                EndTime  string `position:"Query" name:"EndTime"`
+                PageSize  string `position:"Query" name:"PageSize"`
+                Version  string `position:"Query" name:"Version"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                StartTime  string `position:"Query" name:"StartTime"`
+                PageNumber  string `position:"Query" name:"PageNumber"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type BatchDescribeDomainBpsDataResponse struct {
-	*responses.BaseResponse
-	RequestId  string `json:"RequestId"`
-	PageNumber int    `json:"PageNumber"`
-	PageSize   int    `json:"PageSize"`
-	TotalCount int    `json:"TotalCount"`
-	BpsDatas   []struct {
-		Timestamp  string  `json:"Timestamp"`
-		L1Bps      float64 `json:"L1Bps"`
-		DomainName string  `json:"DomainName"`
-	} `json:"BpsDatas"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            PageNumber     int `json:"PageNumber" xml:"PageNumber"`
+            PageSize     int `json:"PageSize" xml:"PageSize"`
+            TotalCount     int `json:"TotalCount" xml:"TotalCount"`
+                BpsDatas struct {
+                    DataModule []struct {
+            Timestamp     string `json:"Timestamp" xml:"Timestamp"`
+            L1Bps     float64 `json:"L1Bps" xml:"L1Bps"`
+            L1InnerBps     float64 `json:"L1InnerBps" xml:"L1InnerBps"`
+            L1OutBps     float64 `json:"L1OutBps" xml:"L1OutBps"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+                    }   `json:"DataModule" xml:"DataModule"`
+                } `json:"BpsDatas" xml:"BpsDatas"`
 }
 
 func CreateBatchDescribeDomainBpsDataRequest() (request *BatchDescribeDomainBpsDataRequest) {
-	request = &BatchDescribeDomainBpsDataRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "BatchDescribeDomainBpsData", "", "")
-	return
+request = &BatchDescribeDomainBpsDataRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "BatchDescribeDomainBpsData", "", "")
+return
 }
 
 func CreateBatchDescribeDomainBpsDataResponse() (response *BatchDescribeDomainBpsDataResponse) {
-	response = &BatchDescribeDomainBpsDataResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &BatchDescribeDomainBpsDataResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/clear_user_black_list.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,77 +17,77 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ClearUserBlackList(request *ClearUserBlackListRequest) (response *ClearUserBlackListResponse, err error) {
-	response = CreateClearUserBlackListResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateClearUserBlackListResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ClearUserBlackListWithChan(request *ClearUserBlackListRequest) (<-chan *ClearUserBlackListResponse, <-chan error) {
-	responseChan := make(chan *ClearUserBlackListResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ClearUserBlackList(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ClearUserBlackListResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ClearUserBlackList(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ClearUserBlackListWithCallback(request *ClearUserBlackListRequest, callback func(response *ClearUserBlackListResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ClearUserBlackListResponse
-		var err error
-		defer close(result)
-		response, err = client.ClearUserBlackList(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ClearUserBlackListWithCallback(request *ClearUserBlackListRequest, callback func(response *ClearUserBlackListResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ClearUserBlackListResponse
+var err error
+defer close(result)
+response, err = client.ClearUserBlackList(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ClearUserBlackListRequest struct {
-	*requests.RpcRequest
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	OwnerAccount  string `position:"Query" name:"OwnerAccount"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type ClearUserBlackListResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateClearUserBlackListRequest() (request *ClearUserBlackListRequest) {
-	request = &ClearUserBlackListRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "ClearUserBlackList", "", "")
-	return
+request = &ClearUserBlackListRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "ClearUserBlackList", "", "")
+return
 }
 
 func CreateClearUserBlackListResponse() (response *ClearUserBlackListResponse) {
-	response = &ClearUserBlackListResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ClearUserBlackListResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/clear_user_domain_black_list.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,78 +17,78 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ClearUserDomainBlackList(request *ClearUserDomainBlackListRequest) (response *ClearUserDomainBlackListResponse, err error) {
-	response = CreateClearUserDomainBlackListResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateClearUserDomainBlackListResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) ClearUserDomainBlackListWithChan(request *ClearUserDomainBlackListRequest) (<-chan *ClearUserDomainBlackListResponse, <-chan error) {
-	responseChan := make(chan *ClearUserDomainBlackListResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.ClearUserDomainBlackList(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *ClearUserDomainBlackListResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.ClearUserDomainBlackList(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) ClearUserDomainBlackListWithCallback(request *ClearUserDomainBlackListRequest, callback func(response *ClearUserDomainBlackListResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *ClearUserDomainBlackListResponse
-		var err error
-		defer close(result)
-		response, err = client.ClearUserDomainBlackList(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) ClearUserDomainBlackListWithCallback(request *ClearUserDomainBlackListRequest, callback func(response *ClearUserDomainBlackListResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *ClearUserDomainBlackListResponse
+var err error
+defer close(result)
+response, err = client.ClearUserDomainBlackList(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type ClearUserDomainBlackListRequest struct {
-	*requests.RpcRequest
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	OwnerAccount  string `position:"Query" name:"OwnerAccount"`
-	DomainName    string `position:"Query" name:"DomainName"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type ClearUserDomainBlackListResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateClearUserDomainBlackListRequest() (request *ClearUserDomainBlackListRequest) {
-	request = &ClearUserDomainBlackListRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "ClearUserDomainBlackList", "", "")
-	return
+request = &ClearUserDomainBlackListRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "ClearUserDomainBlackList", "", "")
+return
 }
 
 func CreateClearUserDomainBlackListResponse() (response *ClearUserDomainBlackListResponse) {
-	response = &ClearUserDomainBlackListResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &ClearUserDomainBlackListResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/client.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,28 +17,28 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth"
+    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
+    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth"
 )
 
 type Client struct {
-	sdk.Client
+    sdk.Client
 }
 
 func NewClient() (client *Client, err error) {
-	client = &Client{}
-	err = client.Init()
-	return
+    client = &Client{}
+    err = client.Init()
+    return
 }
 
 func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error) {
-	client = &Client{}
-	err = client.InitWithOptions(regionId, config, credential)
-	return
+    client = &Client{}
+    err = client.InitWithOptions(regionId, config, credential)
+    return
 }
 
 func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error) {
-	client = &Client{}
-	err = client.InitWithAccessKey(regionId, accessKeyId, accessKeySecret)
-	return
+    client = &Client{}
+    err = client.InitWithAccessKey(regionId, accessKeyId, accessKeySecret)
+    return
 }

services/cdn/create_live_stream_record_index_files.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,92 +17,92 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) CreateLiveStreamRecordIndexFiles(request *CreateLiveStreamRecordIndexFilesRequest) (response *CreateLiveStreamRecordIndexFilesResponse, err error) {
-	response = CreateCreateLiveStreamRecordIndexFilesResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateCreateLiveStreamRecordIndexFilesResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) CreateLiveStreamRecordIndexFilesWithChan(request *CreateLiveStreamRecordIndexFilesRequest) (<-chan *CreateLiveStreamRecordIndexFilesResponse, <-chan error) {
-	responseChan := make(chan *CreateLiveStreamRecordIndexFilesResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.CreateLiveStreamRecordIndexFiles(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *CreateLiveStreamRecordIndexFilesResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.CreateLiveStreamRecordIndexFiles(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) CreateLiveStreamRecordIndexFilesWithCallback(request *CreateLiveStreamRecordIndexFilesRequest, callback func(response *CreateLiveStreamRecordIndexFilesResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *CreateLiveStreamRecordIndexFilesResponse
-		var err error
-		defer close(result)
-		response, err = client.CreateLiveStreamRecordIndexFiles(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) CreateLiveStreamRecordIndexFilesWithCallback(request *CreateLiveStreamRecordIndexFilesRequest, callback func(response *CreateLiveStreamRecordIndexFilesResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *CreateLiveStreamRecordIndexFilesResponse
+var err error
+defer close(result)
+response, err = client.CreateLiveStreamRecordIndexFiles(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type CreateLiveStreamRecordIndexFilesRequest struct {
-	*requests.RpcRequest
-	OssBucket     string `position:"Query" name:"OssBucket"`
-	AppName       string `position:"Query" name:"AppName"`
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	DomainName    string `position:"Query" name:"DomainName"`
-	OssEndpoint   string `position:"Query" name:"OssEndpoint"`
-	Action        string `position:"Query" name:"Action"`
-	EndTime       string `position:"Query" name:"EndTime"`
-	StartTime     string `position:"Query" name:"StartTime"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	StreamName    string `position:"Query" name:"StreamName"`
-	OssObject     string `position:"Query" name:"OssObject"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                EndTime  string `position:"Query" name:"EndTime"`
+                StreamName  string `position:"Query" name:"StreamName"`
+                StartTime  string `position:"Query" name:"StartTime"`
+                OssBucket  string `position:"Query" name:"OssBucket"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                OssEndpoint  string `position:"Query" name:"OssEndpoint"`
+                AppName  string `position:"Query" name:"AppName"`
+                OssObject  string `position:"Query" name:"OssObject"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type CreateLiveStreamRecordIndexFilesResponse struct {
-	*responses.BaseResponse
-	RequestId  string `json:"RequestId"`
-	RecordInfo struct {
-		RecordId   string  `json:"RecordId"`
-		RecordUrl  string  `json:"RecordUrl"`
-		Duration   float64 `json:"Duration"`
-		Height     int     `json:"Height"`
-		Width      int     `json:"Width"`
-		CreateTime string  `json:"CreateTime"`
-	} `json:"RecordInfo"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            RecordInfo struct {
+            RecordId     string `json:"RecordId" xml:"RecordId"`
+            RecordUrl     string `json:"RecordUrl" xml:"RecordUrl"`
+            Duration     float64 `json:"Duration" xml:"Duration"`
+            Height     int `json:"Height" xml:"Height"`
+            Width     int `json:"Width" xml:"Width"`
+            CreateTime     string `json:"CreateTime" xml:"CreateTime"`
+            }  `json:"RecordInfo" xml:"RecordInfo"`
 }
 
 func CreateCreateLiveStreamRecordIndexFilesRequest() (request *CreateLiveStreamRecordIndexFilesRequest) {
-	request = &CreateLiveStreamRecordIndexFilesRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "CreateLiveStreamRecordIndexFiles", "", "")
-	return
+request = &CreateLiveStreamRecordIndexFilesRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "CreateLiveStreamRecordIndexFiles", "", "")
+return
 }
 
 func CreateCreateLiveStreamRecordIndexFilesResponse() (response *CreateLiveStreamRecordIndexFilesResponse) {
-	response = &CreateLiveStreamRecordIndexFilesResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &CreateLiveStreamRecordIndexFilesResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/delete_cdn_domain.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,78 +17,78 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteCdnDomain(request *DeleteCdnDomainRequest) (response *DeleteCdnDomainResponse, err error) {
-	response = CreateDeleteCdnDomainResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDeleteCdnDomainResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DeleteCdnDomainWithChan(request *DeleteCdnDomainRequest) (<-chan *DeleteCdnDomainResponse, <-chan error) {
-	responseChan := make(chan *DeleteCdnDomainResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DeleteCdnDomain(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DeleteCdnDomainResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DeleteCdnDomain(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DeleteCdnDomainWithCallback(request *DeleteCdnDomainRequest, callback func(response *DeleteCdnDomainResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DeleteCdnDomainResponse
-		var err error
-		defer close(result)
-		response, err = client.DeleteCdnDomain(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DeleteCdnDomainWithCallback(request *DeleteCdnDomainRequest, callback func(response *DeleteCdnDomainResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DeleteCdnDomainResponse
+var err error
+defer close(result)
+response, err = client.DeleteCdnDomain(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DeleteCdnDomainRequest struct {
-	*requests.RpcRequest
-	ResourceGroupId string `position:"Query" name:"ResourceGroupId"`
-	SecurityToken   string `position:"Query" name:"SecurityToken"`
-	DomainName      string `position:"Query" name:"DomainName"`
-	Action          string `position:"Query" name:"Action"`
-	OwnerId         string `position:"Query" name:"OwnerId"`
-	AccessKeyId     string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                ResourceGroupId  string `position:"Query" name:"ResourceGroupId"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type DeleteCdnDomainResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateDeleteCdnDomainRequest() (request *DeleteCdnDomainRequest) {
-	request = &DeleteCdnDomainRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteCdnDomain", "", "")
-	return
+request = &DeleteCdnDomainRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteCdnDomain", "", "")
+return
 }
 
 func CreateDeleteCdnDomainResponse() (response *DeleteCdnDomainResponse) {
-	response = &DeleteCdnDomainResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DeleteCdnDomainResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/delete_http_header_config.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,78 +17,78 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteHttpHeaderConfig(request *DeleteHttpHeaderConfigRequest) (response *DeleteHttpHeaderConfigResponse, err error) {
-	response = CreateDeleteHttpHeaderConfigResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDeleteHttpHeaderConfigResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DeleteHttpHeaderConfigWithChan(request *DeleteHttpHeaderConfigRequest) (<-chan *DeleteHttpHeaderConfigResponse, <-chan error) {
-	responseChan := make(chan *DeleteHttpHeaderConfigResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DeleteHttpHeaderConfig(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DeleteHttpHeaderConfigResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DeleteHttpHeaderConfig(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DeleteHttpHeaderConfigWithCallback(request *DeleteHttpHeaderConfigRequest, callback func(response *DeleteHttpHeaderConfigResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DeleteHttpHeaderConfigResponse
-		var err error
-		defer close(result)
-		response, err = client.DeleteHttpHeaderConfig(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DeleteHttpHeaderConfigWithCallback(request *DeleteHttpHeaderConfigRequest, callback func(response *DeleteHttpHeaderConfigResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DeleteHttpHeaderConfigResponse
+var err error
+defer close(result)
+response, err = client.DeleteHttpHeaderConfig(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DeleteHttpHeaderConfigRequest struct {
-	*requests.RpcRequest
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	ConfigID      string `position:"Query" name:"ConfigID"`
-	DomainName    string `position:"Query" name:"DomainName"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                ConfigID  string `position:"Query" name:"ConfigID"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type DeleteHttpHeaderConfigResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateDeleteHttpHeaderConfigRequest() (request *DeleteHttpHeaderConfigRequest) {
-	request = &DeleteHttpHeaderConfigRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteHttpHeaderConfig", "", "")
-	return
+request = &DeleteHttpHeaderConfigRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteHttpHeaderConfig", "", "")
+return
 }
 
 func CreateDeleteHttpHeaderConfigResponse() (response *DeleteHttpHeaderConfigResponse) {
-	response = &DeleteHttpHeaderConfigResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DeleteHttpHeaderConfigResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/delete_live_app_record_config.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,78 +17,78 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteLiveAppRecordConfig(request *DeleteLiveAppRecordConfigRequest) (response *DeleteLiveAppRecordConfigResponse, err error) {
-	response = CreateDeleteLiveAppRecordConfigResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDeleteLiveAppRecordConfigResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DeleteLiveAppRecordConfigWithChan(request *DeleteLiveAppRecordConfigRequest) (<-chan *DeleteLiveAppRecordConfigResponse, <-chan error) {
-	responseChan := make(chan *DeleteLiveAppRecordConfigResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DeleteLiveAppRecordConfig(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DeleteLiveAppRecordConfigResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DeleteLiveAppRecordConfig(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DeleteLiveAppRecordConfigWithCallback(request *DeleteLiveAppRecordConfigRequest, callback func(response *DeleteLiveAppRecordConfigResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DeleteLiveAppRecordConfigResponse
-		var err error
-		defer close(result)
-		response, err = client.DeleteLiveAppRecordConfig(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DeleteLiveAppRecordConfigWithCallback(request *DeleteLiveAppRecordConfigRequest, callback func(response *DeleteLiveAppRecordConfigResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DeleteLiveAppRecordConfigResponse
+var err error
+defer close(result)
+response, err = client.DeleteLiveAppRecordConfig(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DeleteLiveAppRecordConfigRequest struct {
-	*requests.RpcRequest
-	AppName       string `position:"Query" name:"AppName"`
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	DomainName    string `position:"Query" name:"DomainName"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                AppName  string `position:"Query" name:"AppName"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type DeleteLiveAppRecordConfigResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateDeleteLiveAppRecordConfigRequest() (request *DeleteLiveAppRecordConfigRequest) {
-	request = &DeleteLiveAppRecordConfigRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveAppRecordConfig", "", "")
-	return
+request = &DeleteLiveAppRecordConfigRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveAppRecordConfig", "", "")
+return
 }
 
 func CreateDeleteLiveAppRecordConfigResponse() (response *DeleteLiveAppRecordConfigResponse) {
-	response = &DeleteLiveAppRecordConfigResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DeleteLiveAppRecordConfigResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/delete_live_app_snapshot_config.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,78 +17,78 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteLiveAppSnapshotConfig(request *DeleteLiveAppSnapshotConfigRequest) (response *DeleteLiveAppSnapshotConfigResponse, err error) {
-	response = CreateDeleteLiveAppSnapshotConfigResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDeleteLiveAppSnapshotConfigResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DeleteLiveAppSnapshotConfigWithChan(request *DeleteLiveAppSnapshotConfigRequest) (<-chan *DeleteLiveAppSnapshotConfigResponse, <-chan error) {
-	responseChan := make(chan *DeleteLiveAppSnapshotConfigResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DeleteLiveAppSnapshotConfig(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DeleteLiveAppSnapshotConfigResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DeleteLiveAppSnapshotConfig(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DeleteLiveAppSnapshotConfigWithCallback(request *DeleteLiveAppSnapshotConfigRequest, callback func(response *DeleteLiveAppSnapshotConfigResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DeleteLiveAppSnapshotConfigResponse
-		var err error
-		defer close(result)
-		response, err = client.DeleteLiveAppSnapshotConfig(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DeleteLiveAppSnapshotConfigWithCallback(request *DeleteLiveAppSnapshotConfigRequest, callback func(response *DeleteLiveAppSnapshotConfigResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DeleteLiveAppSnapshotConfigResponse
+var err error
+defer close(result)
+response, err = client.DeleteLiveAppSnapshotConfig(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DeleteLiveAppSnapshotConfigRequest struct {
-	*requests.RpcRequest
-	AppName       string `position:"Query" name:"AppName"`
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	DomainName    string `position:"Query" name:"DomainName"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                AppName  string `position:"Query" name:"AppName"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type DeleteLiveAppSnapshotConfigResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateDeleteLiveAppSnapshotConfigRequest() (request *DeleteLiveAppSnapshotConfigRequest) {
-	request = &DeleteLiveAppSnapshotConfigRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveAppSnapshotConfig", "", "")
-	return
+request = &DeleteLiveAppSnapshotConfigRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveAppSnapshotConfig", "", "")
+return
 }
 
 func CreateDeleteLiveAppSnapshotConfigResponse() (response *DeleteLiveAppSnapshotConfigResponse) {
-	response = &DeleteLiveAppSnapshotConfigResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DeleteLiveAppSnapshotConfigResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/delete_live_domain_mapping.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,78 +17,78 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteLiveDomainMapping(request *DeleteLiveDomainMappingRequest) (response *DeleteLiveDomainMappingResponse, err error) {
-	response = CreateDeleteLiveDomainMappingResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDeleteLiveDomainMappingResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DeleteLiveDomainMappingWithChan(request *DeleteLiveDomainMappingRequest) (<-chan *DeleteLiveDomainMappingResponse, <-chan error) {
-	responseChan := make(chan *DeleteLiveDomainMappingResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DeleteLiveDomainMapping(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DeleteLiveDomainMappingResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DeleteLiveDomainMapping(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DeleteLiveDomainMappingWithCallback(request *DeleteLiveDomainMappingRequest, callback func(response *DeleteLiveDomainMappingResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DeleteLiveDomainMappingResponse
-		var err error
-		defer close(result)
-		response, err = client.DeleteLiveDomainMapping(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DeleteLiveDomainMappingWithCallback(request *DeleteLiveDomainMappingRequest, callback func(response *DeleteLiveDomainMappingResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DeleteLiveDomainMappingResponse
+var err error
+defer close(result)
+response, err = client.DeleteLiveDomainMapping(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DeleteLiveDomainMappingRequest struct {
-	*requests.RpcRequest
-	PullDomain    string `position:"Query" name:"PullDomain"`
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	PushDomain    string `position:"Query" name:"PushDomain"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                PullDomain  string `position:"Query" name:"PullDomain"`
+                PushDomain  string `position:"Query" name:"PushDomain"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type DeleteLiveDomainMappingResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateDeleteLiveDomainMappingRequest() (request *DeleteLiveDomainMappingRequest) {
-	request = &DeleteLiveDomainMappingRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveDomainMapping", "", "")
-	return
+request = &DeleteLiveDomainMappingRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveDomainMapping", "", "")
+return
 }
 
 func CreateDeleteLiveDomainMappingResponse() (response *DeleteLiveDomainMappingResponse) {
-	response = &DeleteLiveDomainMappingResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DeleteLiveDomainMappingResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/delete_live_pull_stream_info.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,79 +17,79 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteLivePullStreamInfo(request *DeleteLivePullStreamInfoRequest) (response *DeleteLivePullStreamInfoResponse, err error) {
-	response = CreateDeleteLivePullStreamInfoResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDeleteLivePullStreamInfoResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DeleteLivePullStreamInfoWithChan(request *DeleteLivePullStreamInfoRequest) (<-chan *DeleteLivePullStreamInfoResponse, <-chan error) {
-	responseChan := make(chan *DeleteLivePullStreamInfoResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DeleteLivePullStreamInfo(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DeleteLivePullStreamInfoResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DeleteLivePullStreamInfo(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DeleteLivePullStreamInfoWithCallback(request *DeleteLivePullStreamInfoRequest, callback func(response *DeleteLivePullStreamInfoResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DeleteLivePullStreamInfoResponse
-		var err error
-		defer close(result)
-		response, err = client.DeleteLivePullStreamInfo(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DeleteLivePullStreamInfoWithCallback(request *DeleteLivePullStreamInfoRequest, callback func(response *DeleteLivePullStreamInfoResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DeleteLivePullStreamInfoResponse
+var err error
+defer close(result)
+response, err = client.DeleteLivePullStreamInfo(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DeleteLivePullStreamInfoRequest struct {
-	*requests.RpcRequest
-	AppName       string `position:"Query" name:"AppName"`
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	DomainName    string `position:"Query" name:"DomainName"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	StreamName    string `position:"Query" name:"StreamName"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                StreamName  string `position:"Query" name:"StreamName"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                AppName  string `position:"Query" name:"AppName"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type DeleteLivePullStreamInfoResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateDeleteLivePullStreamInfoRequest() (request *DeleteLivePullStreamInfoRequest) {
-	request = &DeleteLivePullStreamInfoRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLivePullStreamInfo", "", "")
-	return
+request = &DeleteLivePullStreamInfoRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLivePullStreamInfo", "", "")
+return
 }
 
 func CreateDeleteLivePullStreamInfoResponse() (response *DeleteLivePullStreamInfoResponse) {
-	response = &DeleteLivePullStreamInfoResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DeleteLivePullStreamInfoResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/delete_live_stream_transcode.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,80 +17,80 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteLiveStreamTranscode(request *DeleteLiveStreamTranscodeRequest) (response *DeleteLiveStreamTranscodeResponse, err error) {
-	response = CreateDeleteLiveStreamTranscodeResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDeleteLiveStreamTranscodeResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DeleteLiveStreamTranscodeWithChan(request *DeleteLiveStreamTranscodeRequest) (<-chan *DeleteLiveStreamTranscodeResponse, <-chan error) {
-	responseChan := make(chan *DeleteLiveStreamTranscodeResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DeleteLiveStreamTranscode(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DeleteLiveStreamTranscodeResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DeleteLiveStreamTranscode(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DeleteLiveStreamTranscodeWithCallback(request *DeleteLiveStreamTranscodeRequest, callback func(response *DeleteLiveStreamTranscodeResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DeleteLiveStreamTranscodeResponse
-		var err error
-		defer close(result)
-		response, err = client.DeleteLiveStreamTranscode(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DeleteLiveStreamTranscodeWithCallback(request *DeleteLiveStreamTranscodeRequest, callback func(response *DeleteLiveStreamTranscodeResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DeleteLiveStreamTranscodeResponse
+var err error
+defer close(result)
+response, err = client.DeleteLiveStreamTranscode(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DeleteLiveStreamTranscodeRequest struct {
-	*requests.RpcRequest
-	Template      string `position:"Query" name:"Template"`
-	App           string `position:"Query" name:"App"`
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	OwnerAccount  string `position:"Query" name:"OwnerAccount"`
-	Domain        string `position:"Query" name:"Domain"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                Template  string `position:"Query" name:"Template"`
+                App  string `position:"Query" name:"App"`
+                Domain  string `position:"Query" name:"Domain"`
+                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type DeleteLiveStreamTranscodeResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateDeleteLiveStreamTranscodeRequest() (request *DeleteLiveStreamTranscodeRequest) {
-	request = &DeleteLiveStreamTranscodeRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveStreamTranscode", "", "")
-	return
+request = &DeleteLiveStreamTranscodeRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveStreamTranscode", "", "")
+return
 }
 
 func CreateDeleteLiveStreamTranscodeResponse() (response *DeleteLiveStreamTranscodeResponse) {
-	response = &DeleteLiveStreamTranscodeResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DeleteLiveStreamTranscodeResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/describe_cdn_domain_base_detail.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,89 +17,91 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeCdnDomainBaseDetail(request *DescribeCdnDomainBaseDetailRequest) (response *DescribeCdnDomainBaseDetailResponse, err error) {
-	response = CreateDescribeCdnDomainBaseDetailResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeCdnDomainBaseDetailResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeCdnDomainBaseDetailWithChan(request *DescribeCdnDomainBaseDetailRequest) (<-chan *DescribeCdnDomainBaseDetailResponse, <-chan error) {
-	responseChan := make(chan *DescribeCdnDomainBaseDetailResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeCdnDomainBaseDetail(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeCdnDomainBaseDetailResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeCdnDomainBaseDetail(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeCdnDomainBaseDetailWithCallback(request *DescribeCdnDomainBaseDetailRequest, callback func(response *DescribeCdnDomainBaseDetailResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeCdnDomainBaseDetailResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeCdnDomainBaseDetail(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeCdnDomainBaseDetailWithCallback(request *DescribeCdnDomainBaseDetailRequest, callback func(response *DescribeCdnDomainBaseDetailResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeCdnDomainBaseDetailResponse
+var err error
+defer close(result)
+response, err = client.DescribeCdnDomainBaseDetail(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeCdnDomainBaseDetailRequest struct {
-	*requests.RpcRequest
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	DomainName    string `position:"Query" name:"DomainName"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type DescribeCdnDomainBaseDetailResponse struct {
-	*responses.BaseResponse
-	RequestId             string `json:"RequestId"`
-	DomainBaseDetailModel struct {
-		Cname        string   `json:"Cname"`
-		CdnType      string   `json:"CdnType"`
-		DomainStatus string   `json:"DomainStatus"`
-		SourceType   string   `json:"SourceType"`
-		Region       string   `json:"Region"`
-		DomainName   string   `json:"DomainName"`
-		Remark       string   `json:"Remark"`
-		GmtModified  string   `json:"GmtModified"`
-		GmtCreated   string   `json:"GmtCreated"`
-		Sources      []string `json:"Sources"`
-	} `json:"DomainBaseDetailModel"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            DomainBaseDetailModel struct {
+            Cname     string `json:"Cname" xml:"Cname"`
+            CdnType     string `json:"CdnType" xml:"CdnType"`
+            DomainStatus     string `json:"DomainStatus" xml:"DomainStatus"`
+            SourceType     string `json:"SourceType" xml:"SourceType"`
+            Region     string `json:"Region" xml:"Region"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            Remark     string `json:"Remark" xml:"Remark"`
+            GmtModified     string `json:"GmtModified" xml:"GmtModified"`
+            GmtCreated     string `json:"GmtCreated" xml:"GmtCreated"`
+                Sources struct {
+                Source []    string `json:"Source" xml:"Source"`
+                } `json:"Sources" xml:"Sources"`
+            }  `json:"DomainBaseDetailModel" xml:"DomainBaseDetailModel"`
 }
 
 func CreateDescribeCdnDomainBaseDetailRequest() (request *DescribeCdnDomainBaseDetailRequest) {
-	request = &DescribeCdnDomainBaseDetailRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnDomainBaseDetail", "", "")
-	return
+request = &DescribeCdnDomainBaseDetailRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnDomainBaseDetail", "", "")
+return
 }
 
 func CreateDescribeCdnDomainBaseDetailResponse() (response *DescribeCdnDomainBaseDetailResponse) {
-	response = &DescribeCdnDomainBaseDetailResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeCdnDomainBaseDetailResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/describe_cdn_domain_detail.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,103 +17,107 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeCdnDomainDetail(request *DescribeCdnDomainDetailRequest) (response *DescribeCdnDomainDetailResponse, err error) {
-	response = CreateDescribeCdnDomainDetailResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeCdnDomainDetailResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeCdnDomainDetailWithChan(request *DescribeCdnDomainDetailRequest) (<-chan *DescribeCdnDomainDetailResponse, <-chan error) {
-	responseChan := make(chan *DescribeCdnDomainDetailResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeCdnDomainDetail(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeCdnDomainDetailResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeCdnDomainDetail(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeCdnDomainDetailWithCallback(request *DescribeCdnDomainDetailRequest, callback func(response *DescribeCdnDomainDetailResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeCdnDomainDetailResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeCdnDomainDetail(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeCdnDomainDetailWithCallback(request *DescribeCdnDomainDetailRequest, callback func(response *DescribeCdnDomainDetailResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeCdnDomainDetailResponse
+var err error
+defer close(result)
+response, err = client.DescribeCdnDomainDetail(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeCdnDomainDetailRequest struct {
-	*requests.RpcRequest
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	DomainName    string `position:"Query" name:"DomainName"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                DomainName  string `position:"Query" name:"DomainName"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type DescribeCdnDomainDetailResponse struct {
-	*responses.BaseResponse
-	RequestId            string `json:"RequestId"`
-	GetDomainDetailModel struct {
-		GmtCreated              string   `json:"GmtCreated"`
-		GmtModified             string   `json:"GmtModified"`
-		SourceType              string   `json:"SourceType"`
-		DomainStatus            string   `json:"DomainStatus"`
-		SourcePort              int      `json:"SourcePort"`
-		CdnType                 string   `json:"CdnType"`
-		Cname                   string   `json:"Cname"`
-		HttpsCname              string   `json:"HttpsCname"`
-		DomainName              string   `json:"DomainName"`
-		Description             string   `json:"Description"`
-		ServerCertificateStatus string   `json:"ServerCertificateStatus"`
-		ServerCertificate       string   `json:"ServerCertificate"`
-		Region                  string   `json:"Region"`
-		Scope                   string   `json:"Scope"`
-		CertificateName         string   `json:"CertificateName"`
-		ResourceGroupId         string   `json:"ResourceGroupId"`
-		Sources                 []string `json:"Sources"`
-		SourceModels            []struct {
-			Content  string `json:"Content"`
-			Type     string `json:"Type"`
-			Port     int    `json:"Port"`
-			Enabled  string `json:"Enabled"`
-			Priority string `json:"Priority"`
-		} `json:"SourceModels"`
-	} `json:"GetDomainDetailModel"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            GetDomainDetailModel struct {
+            GmtCreated     string `json:"GmtCreated" xml:"GmtCreated"`
+            GmtModified     string `json:"GmtModified" xml:"GmtModified"`
+            SourceType     string `json:"SourceType" xml:"SourceType"`
+            DomainStatus     string `json:"DomainStatus" xml:"DomainStatus"`
+            SourcePort     int `json:"SourcePort" xml:"SourcePort"`
+            CdnType     string `json:"CdnType" xml:"CdnType"`
+            Cname     string `json:"Cname" xml:"Cname"`
+            HttpsCname     string `json:"HttpsCname" xml:"HttpsCname"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            Description     string `json:"Description" xml:"Description"`
+            ServerCertificateStatus     string `json:"ServerCertificateStatus" xml:"ServerCertificateStatus"`
+            ServerCertificate     string `json:"ServerCertificate" xml:"ServerCertificate"`
+            Region     string `json:"Region" xml:"Region"`
+            Scope     string `json:"Scope" xml:"Scope"`
+            CertificateName     string `json:"CertificateName" xml:"CertificateName"`
+            ResourceGroupId     string `json:"ResourceGroupId" xml:"ResourceGroupId"`
+                Sources struct {
+                Source []    string `json:"Source" xml:"Source"`
+                } `json:"Sources" xml:"Sources"`
+                SourceModels struct {
+                    SourceModel []struct {
+            Content     string `json:"Content" xml:"Content"`
+            Type     string `json:"Type" xml:"Type"`
+            Port     int `json:"Port" xml:"Port"`
+            Enabled     string `json:"Enabled" xml:"Enabled"`
+            Priority     string `json:"Priority" xml:"Priority"`
+                    }   `json:"SourceModel" xml:"SourceModel"`
+                } `json:"SourceModels" xml:"SourceModels"`
+            }  `json:"GetDomainDetailModel" xml:"GetDomainDetailModel"`
 }
 
 func CreateDescribeCdnDomainDetailRequest() (request *DescribeCdnDomainDetailRequest) {
-	request = &DescribeCdnDomainDetailRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnDomainDetail", "", "")
-	return
+request = &DescribeCdnDomainDetailRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnDomainDetail", "", "")
+return
 }
 
 func CreateDescribeCdnDomainDetailResponse() (response *DescribeCdnDomainDetailResponse) {
-	response = &DescribeCdnDomainDetailResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeCdnDomainDetailResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/describe_cdn_domain_logs.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,95 +17,97 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeCdnDomainLogs(request *DescribeCdnDomainLogsRequest) (response *DescribeCdnDomainLogsResponse, err error) {
-	response = CreateDescribeCdnDomainLogsResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeCdnDomainLogsResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeCdnDomainLogsWithChan(request *DescribeCdnDomainLogsRequest) (<-chan *DescribeCdnDomainLogsResponse, <-chan error) {
-	responseChan := make(chan *DescribeCdnDomainLogsResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeCdnDomainLogs(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeCdnDomainLogsResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeCdnDomainLogs(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeCdnDomainLogsWithCallback(request *DescribeCdnDomainLogsRequest, callback func(response *DescribeCdnDomainLogsResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeCdnDomainLogsResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeCdnDomainLogs(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeCdnDomainLogsWithCallback(request *DescribeCdnDomainLogsRequest, callback func(response *DescribeCdnDomainLogsResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeCdnDomainLogsResponse
+var err error
+defer close(result)
+response, err = client.DescribeCdnDomainLogs(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeCdnDomainLogsRequest struct {
-	*requests.RpcRequest
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	DomainName    string `position:"Query" name:"DomainName"`
-	PageSize      string `position:"Query" name:"PageSize"`
-	Action        string `position:"Query" name:"Action"`
-	EndTime       string `position:"Query" name:"EndTime"`
-	StartTime     string `position:"Query" name:"StartTime"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	PageNumber    string `position:"Query" name:"PageNumber"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
-	LogDay        string `position:"Query" name:"LogDay"`
+*requests.RpcRequest
+                EndTime  string `position:"Query" name:"EndTime"`
+                PageSize  string `position:"Query" name:"PageSize"`
+                StartTime  string `position:"Query" name:"StartTime"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                PageNumber  string `position:"Query" name:"PageNumber"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                LogDay  string `position:"Query" name:"LogDay"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type DescribeCdnDomainLogsResponse struct {
-	*responses.BaseResponse
-	RequestId      string `json:"RequestId"`
-	PageNumber     int64  `json:"PageNumber"`
-	PageSize       int64  `json:"PageSize"`
-	TotalCount     int64  `json:"TotalCount"`
-	DomainLogModel struct {
-		DomainName       string `json:"DomainName"`
-		DomainLogDetails []struct {
-			LogName   string `json:"LogName"`
-			LogPath   string `json:"LogPath"`
-			LogSize   int64  `json:"LogSize"`
-			StartTime string `json:"StartTime"`
-			EndTime   string `json:"EndTime"`
-		} `json:"DomainLogDetails"`
-	} `json:"DomainLogModel"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
+            PageSize     int64 `json:"PageSize" xml:"PageSize"`
+            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
+            DomainLogModel struct {
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+                DomainLogDetails struct {
+                    DomainLogDetail []struct {
+            LogName     string `json:"LogName" xml:"LogName"`
+            LogPath     string `json:"LogPath" xml:"LogPath"`
+            LogSize     int64 `json:"LogSize" xml:"LogSize"`
+            StartTime     string `json:"StartTime" xml:"StartTime"`
+            EndTime     string `json:"EndTime" xml:"EndTime"`
+                    }   `json:"DomainLogDetail" xml:"DomainLogDetail"`
+                } `json:"DomainLogDetails" xml:"DomainLogDetails"`
+            }  `json:"DomainLogModel" xml:"DomainLogModel"`
 }
 
 func CreateDescribeCdnDomainLogsRequest() (request *DescribeCdnDomainLogsRequest) {
-	request = &DescribeCdnDomainLogsRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnDomainLogs", "", "")
-	return
+request = &DescribeCdnDomainLogsRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnDomainLogs", "", "")
+return
 }
 
 func CreateDescribeCdnDomainLogsResponse() (response *DescribeCdnDomainLogsResponse) {
-	response = &DescribeCdnDomainLogsResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeCdnDomainLogsResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/describe_cdn_monitor_data.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,92 +17,94 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeCdnMonitorData(request *DescribeCdnMonitorDataRequest) (response *DescribeCdnMonitorDataResponse, err error) {
-	response = CreateDescribeCdnMonitorDataResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeCdnMonitorDataResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeCdnMonitorDataWithChan(request *DescribeCdnMonitorDataRequest) (<-chan *DescribeCdnMonitorDataResponse, <-chan error) {
-	responseChan := make(chan *DescribeCdnMonitorDataResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeCdnMonitorData(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeCdnMonitorDataResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeCdnMonitorData(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeCdnMonitorDataWithCallback(request *DescribeCdnMonitorDataRequest, callback func(response *DescribeCdnMonitorDataResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeCdnMonitorDataResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeCdnMonitorData(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeCdnMonitorDataWithCallback(request *DescribeCdnMonitorDataRequest, callback func(response *DescribeCdnMonitorDataResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeCdnMonitorDataResponse
+var err error
+defer close(result)
+response, err = client.DescribeCdnMonitorData(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeCdnMonitorDataRequest struct {
-	*requests.RpcRequest
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	DomainName    string `position:"Query" name:"DomainName"`
-	Action        string `position:"Query" name:"Action"`
-	EndTime       string `position:"Query" name:"EndTime"`
-	Interval      string `position:"Query" name:"Interval"`
-	StartTime     string `position:"Query" name:"StartTime"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                EndTime  string `position:"Query" name:"EndTime"`
+                StartTime  string `position:"Query" name:"StartTime"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                Interval  string `position:"Query" name:"Interval"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type DescribeCdnMonitorDataResponse struct {
-	*responses.BaseResponse
-	RequestId       string `json:"RequestId"`
-	DomainName      string `json:"DomainName"`
-	MonitorInterval int64  `json:"MonitorInterval"`
-	StartTime       string `json:"StartTime"`
-	EndTime         string `json:"EndTime"`
-	MonitorDatas    []struct {
-		TimeStamp         string `json:"TimeStamp"`
-		QueryPerSecond    string `json:"QueryPerSecond"`
-		BytesPerSecond    string `json:"BytesPerSecond"`
-		BytesHitRate      string `json:"BytesHitRate"`
-		RequestHitRate    string `json:"RequestHitRate"`
-		AverageObjectSize string `json:"AverageObjectSize"`
-	} `json:"MonitorDatas"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            MonitorInterval     int64 `json:"MonitorInterval" xml:"MonitorInterval"`
+            StartTime     string `json:"StartTime" xml:"StartTime"`
+            EndTime     string `json:"EndTime" xml:"EndTime"`
+                MonitorDatas struct {
+                    CDNMonitorData []struct {
+            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
+            QueryPerSecond     string `json:"QueryPerSecond" xml:"QueryPerSecond"`
+            BytesPerSecond     string `json:"BytesPerSecond" xml:"BytesPerSecond"`
+            BytesHitRate     string `json:"BytesHitRate" xml:"BytesHitRate"`
+            RequestHitRate     string `json:"RequestHitRate" xml:"RequestHitRate"`
+            AverageObjectSize     string `json:"AverageObjectSize" xml:"AverageObjectSize"`
+                    }   `json:"CDNMonitorData" xml:"CDNMonitorData"`
+                } `json:"MonitorDatas" xml:"MonitorDatas"`
 }
 
 func CreateDescribeCdnMonitorDataRequest() (request *DescribeCdnMonitorDataRequest) {
-	request = &DescribeCdnMonitorDataRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnMonitorData", "", "")
-	return
+request = &DescribeCdnMonitorDataRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnMonitorData", "", "")
+return
 }
 
 func CreateDescribeCdnMonitorDataResponse() (response *DescribeCdnMonitorDataResponse) {
-	response = &DescribeCdnMonitorDataResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeCdnMonitorDataResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/describe_cdn_region_and_isp.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,84 +17,88 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeCdnRegionAndIsp(request *DescribeCdnRegionAndIspRequest) (response *DescribeCdnRegionAndIspResponse, err error) {
-	response = CreateDescribeCdnRegionAndIspResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeCdnRegionAndIspResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeCdnRegionAndIspWithChan(request *DescribeCdnRegionAndIspRequest) (<-chan *DescribeCdnRegionAndIspResponse, <-chan error) {
-	responseChan := make(chan *DescribeCdnRegionAndIspResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeCdnRegionAndIsp(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeCdnRegionAndIspResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeCdnRegionAndIsp(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeCdnRegionAndIspWithCallback(request *DescribeCdnRegionAndIspRequest, callback func(response *DescribeCdnRegionAndIspResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeCdnRegionAndIspResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeCdnRegionAndIsp(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeCdnRegionAndIspWithCallback(request *DescribeCdnRegionAndIspRequest, callback func(response *DescribeCdnRegionAndIspResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeCdnRegionAndIspResponse
+var err error
+defer close(result)
+response, err = client.DescribeCdnRegionAndIsp(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeCdnRegionAndIspRequest struct {
-	*requests.RpcRequest
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type DescribeCdnRegionAndIspResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
-	Regions   []struct {
-		NameZh string `json:"NameZh"`
-		NameEn string `json:"NameEn"`
-	} `json:"Regions"`
-	Isps []struct {
-		NameZh string `json:"NameZh"`
-		NameEn string `json:"NameEn"`
-	} `json:"Isps"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+                Regions struct {
+                    Region []struct {
+            NameZh     string `json:"NameZh" xml:"NameZh"`
+            NameEn     string `json:"NameEn" xml:"NameEn"`
+                    }   `json:"Region" xml:"Region"`
+                } `json:"Regions" xml:"Regions"`
+                Isps struct {
+                    Isp []struct {
+            NameZh     string `json:"NameZh" xml:"NameZh"`
+            NameEn     string `json:"NameEn" xml:"NameEn"`
+                    }   `json:"Isp" xml:"Isp"`
+                } `json:"Isps" xml:"Isps"`
 }
 
 func CreateDescribeCdnRegionAndIspRequest() (request *DescribeCdnRegionAndIspRequest) {
-	request = &DescribeCdnRegionAndIspRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnRegionAndIsp", "", "")
-	return
+request = &DescribeCdnRegionAndIspRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnRegionAndIsp", "", "")
+return
 }
 
 func CreateDescribeCdnRegionAndIspResponse() (response *DescribeCdnRegionAndIspResponse) {
-	response = &DescribeCdnRegionAndIspResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeCdnRegionAndIspResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/describe_cdn_service.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,84 +17,86 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeCdnService(request *DescribeCdnServiceRequest) (response *DescribeCdnServiceResponse, err error) {
-	response = CreateDescribeCdnServiceResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeCdnServiceResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeCdnServiceWithChan(request *DescribeCdnServiceRequest) (<-chan *DescribeCdnServiceResponse, <-chan error) {
-	responseChan := make(chan *DescribeCdnServiceResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeCdnService(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeCdnServiceResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeCdnService(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeCdnServiceWithCallback(request *DescribeCdnServiceRequest, callback func(response *DescribeCdnServiceResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeCdnServiceResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeCdnService(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeCdnServiceWithCallback(request *DescribeCdnServiceRequest, callback func(response *DescribeCdnServiceResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeCdnServiceResponse
+var err error
+defer close(result)
+response, err = client.DescribeCdnService(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeCdnServiceRequest struct {
-	*requests.RpcRequest
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type DescribeCdnServiceResponse struct {
-	*responses.BaseResponse
-	RequestId          string `json:"RequestId"`
-	InstanceId         string `json:"InstanceId"`
-	InternetChargeType string `json:"InternetChargeType"`
-	OpeningTime        string `json:"OpeningTime"`
-	ChangingChargeType string `json:"ChangingChargeType"`
-	ChangingAffectTime string `json:"ChangingAffectTime"`
-	OperationLocks     []struct {
-		LockReason string `json:"LockReason"`
-	} `json:"OperationLocks"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
+            InternetChargeType     string `json:"InternetChargeType" xml:"InternetChargeType"`
+            OpeningTime     string `json:"OpeningTime" xml:"OpeningTime"`
+            ChangingChargeType     string `json:"ChangingChargeType" xml:"ChangingChargeType"`
+            ChangingAffectTime     string `json:"ChangingAffectTime" xml:"ChangingAffectTime"`
+                OperationLocks struct {
+                    LockReason []struct {
+            LockReason     string `json:"LockReason" xml:"LockReason"`
+                    }   `json:"LockReason" xml:"LockReason"`
+                } `json:"OperationLocks" xml:"OperationLocks"`
 }
 
 func CreateDescribeCdnServiceRequest() (request *DescribeCdnServiceRequest) {
-	request = &DescribeCdnServiceRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnService", "", "")
-	return
+request = &DescribeCdnServiceRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnService", "", "")
+return
 }
 
 func CreateDescribeCdnServiceResponse() (response *DescribeCdnServiceResponse) {
-	response = &DescribeCdnServiceResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeCdnServiceResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/describe_cdn_types.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,81 +17,83 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeCdnTypes(request *DescribeCdnTypesRequest) (response *DescribeCdnTypesResponse, err error) {
-	response = CreateDescribeCdnTypesResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeCdnTypesResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeCdnTypesWithChan(request *DescribeCdnTypesRequest) (<-chan *DescribeCdnTypesResponse, <-chan error) {
-	responseChan := make(chan *DescribeCdnTypesResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeCdnTypes(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeCdnTypesResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeCdnTypes(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeCdnTypesWithCallback(request *DescribeCdnTypesRequest, callback func(response *DescribeCdnTypesResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeCdnTypesResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeCdnTypes(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeCdnTypesWithCallback(request *DescribeCdnTypesRequest, callback func(response *DescribeCdnTypesResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeCdnTypesResponse
+var err error
+defer close(result)
+response, err = client.DescribeCdnTypes(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeCdnTypesRequest struct {
-	*requests.RpcRequest
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	OwnerAccount  string `position:"Query" name:"OwnerAccount"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type DescribeCdnTypesResponse struct {
-	*responses.BaseResponse
-	RequestId string `json:"RequestId"`
-	CdnTypes  []struct {
-		Type string `json:"Type"`
-		Desc string `json:"Desc"`
-	} `json:"CdnTypes"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+                CdnTypes struct {
+                    CdnType []struct {
+            Type     string `json:"Type" xml:"Type"`
+            Desc     string `json:"Desc" xml:"Desc"`
+                    }   `json:"CdnType" xml:"CdnType"`
+                } `json:"CdnTypes" xml:"CdnTypes"`
 }
 
 func CreateDescribeCdnTypesRequest() (request *DescribeCdnTypesRequest) {
-	request = &DescribeCdnTypesRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnTypes", "", "")
-	return
+request = &DescribeCdnTypesRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnTypes", "", "")
+return
 }
 
 func CreateDescribeCdnTypesResponse() (response *DescribeCdnTypesResponse) {
-	response = &DescribeCdnTypesResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeCdnTypesResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/describe_domain_average_response_time.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,89 +17,91 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainAverageResponseTime(request *DescribeDomainAverageResponseTimeRequest) (response *DescribeDomainAverageResponseTimeResponse, err error) {
-	response = CreateDescribeDomainAverageResponseTimeResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeDomainAverageResponseTimeResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeDomainAverageResponseTimeWithChan(request *DescribeDomainAverageResponseTimeRequest) (<-chan *DescribeDomainAverageResponseTimeResponse, <-chan error) {
-	responseChan := make(chan *DescribeDomainAverageResponseTimeResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeDomainAverageResponseTime(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeDomainAverageResponseTimeResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeDomainAverageResponseTime(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainAverageResponseTimeWithCallback(request *DescribeDomainAverageResponseTimeRequest, callback func(response *DescribeDomainAverageResponseTimeResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeDomainAverageResponseTimeResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeDomainAverageResponseTime(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeDomainAverageResponseTimeWithCallback(request *DescribeDomainAverageResponseTimeRequest, callback func(response *DescribeDomainAverageResponseTimeResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeDomainAverageResponseTimeResponse
+var err error
+defer close(result)
+response, err = client.DescribeDomainAverageResponseTime(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeDomainAverageResponseTimeRequest struct {
-	*requests.RpcRequest
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	TimeMerge     string `position:"Query" name:"TimeMerge"`
-	DomainName    string `position:"Query" name:"DomainName"`
-	Action        string `position:"Query" name:"Action"`
-	EndTime       string `position:"Query" name:"EndTime"`
-	Interval      string `position:"Query" name:"Interval"`
-	StartTime     string `position:"Query" name:"StartTime"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                EndTime  string `position:"Query" name:"EndTime"`
+                StartTime  string `position:"Query" name:"StartTime"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                Interval  string `position:"Query" name:"Interval"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
+                TimeMerge  string `position:"Query" name:"TimeMerge"`
 }
 
+
 type DescribeDomainAverageResponseTimeResponse struct {
-	*responses.BaseResponse
-	RequestId        string `json:"RequestId"`
-	DomainName       string `json:"DomainName"`
-	DataInterval     string `json:"DataInterval"`
-	StartTime        string `json:"StartTime"`
-	EndTime          string `json:"EndTime"`
-	AvgRTPerInterval []struct {
-		TimeStamp string `json:"TimeStamp"`
-		Value     string `json:"Value"`
-	} `json:"AvgRTPerInterval"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
+            StartTime     string `json:"StartTime" xml:"StartTime"`
+            EndTime     string `json:"EndTime" xml:"EndTime"`
+                AvgRTPerInterval struct {
+                    DataModule []struct {
+            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
+            Value     string `json:"Value" xml:"Value"`
+                    }   `json:"DataModule" xml:"DataModule"`
+                } `json:"AvgRTPerInterval" xml:"AvgRTPerInterval"`
 }
 
 func CreateDescribeDomainAverageResponseTimeRequest() (request *DescribeDomainAverageResponseTimeRequest) {
-	request = &DescribeDomainAverageResponseTimeRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainAverageResponseTime", "", "")
-	return
+request = &DescribeDomainAverageResponseTimeRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainAverageResponseTime", "", "")
+return
 }
 
 func CreateDescribeDomainAverageResponseTimeResponse() (response *DescribeDomainAverageResponseTimeResponse) {
-	response = &DescribeDomainAverageResponseTimeResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeDomainAverageResponseTimeResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/describe_domain_bps_data.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,112 +17,116 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainBpsData(request *DescribeDomainBpsDataRequest) (response *DescribeDomainBpsDataResponse, err error) {
-	response = CreateDescribeDomainBpsDataResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeDomainBpsDataResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeDomainBpsDataWithChan(request *DescribeDomainBpsDataRequest) (<-chan *DescribeDomainBpsDataResponse, <-chan error) {
-	responseChan := make(chan *DescribeDomainBpsDataResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeDomainBpsData(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeDomainBpsDataResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeDomainBpsData(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainBpsDataWithCallback(request *DescribeDomainBpsDataRequest, callback func(response *DescribeDomainBpsDataResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeDomainBpsDataResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeDomainBpsData(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeDomainBpsDataWithCallback(request *DescribeDomainBpsDataRequest, callback func(response *DescribeDomainBpsDataResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeDomainBpsDataResponse
+var err error
+defer close(result)
+response, err = client.DescribeDomainBpsData(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeDomainBpsDataRequest struct {
-	*requests.RpcRequest
-	FixTimeGap     string `position:"Query" name:"FixTimeGap"`
-	TimeMerge      string `position:"Query" name:"TimeMerge"`
-	DomainName     string `position:"Query" name:"DomainName"`
-	EndTime        string `position:"Query" name:"EndTime"`
-	LocationNameEn string `position:"Query" name:"LocationNameEn"`
-	StartTime      string `position:"Query" name:"StartTime"`
-	IspNameEn      string `position:"Query" name:"IspNameEn"`
-	OwnerId        string `position:"Query" name:"OwnerId"`
-	AccessKeyId    string `position:"Query" name:"AccessKeyId"`
-	DomainType     string `position:"Query" name:"DomainType"`
-	SecurityToken  string `position:"Query" name:"SecurityToken"`
-	Action         string `position:"Query" name:"Action"`
-	Interval       string `position:"Query" name:"Interval"`
+*requests.RpcRequest
+                EndTime  string `position:"Query" name:"EndTime"`
+                StartTime  string `position:"Query" name:"StartTime"`
+                Interval  string `position:"Query" name:"Interval"`
+                FixTimeGap  string `position:"Query" name:"FixTimeGap"`
+                LocationNameEn  string `position:"Query" name:"LocationNameEn"`
+                IspNameEn  string `position:"Query" name:"IspNameEn"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                DomainType  string `position:"Query" name:"DomainType"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
+                TimeMerge  string `position:"Query" name:"TimeMerge"`
 }
 
+
 type DescribeDomainBpsDataResponse struct {
-	*responses.BaseResponse
-	RequestId          string `json:"RequestId"`
-	DomainName         string `json:"DomainName"`
-	DataInterval       string `json:"DataInterval"`
-	StartTime          string `json:"StartTime"`
-	EndTime            string `json:"EndTime"`
-	LocationNameEn     string `json:"LocationNameEn"`
-	IspNameEn          string `json:"IspNameEn"`
-	LocationName       string `json:"LocationName"`
-	IspName            string `json:"IspName"`
-	BpsDataPerInterval []struct {
-		TimeStamp            string `json:"TimeStamp"`
-		Value                string `json:"Value"`
-		DomesticValue        string `json:"DomesticValue"`
-		OverseasValue        string `json:"OverseasValue"`
-		DynamicValue         string `json:"DynamicValue"`
-		DynamicDomesticValue string `json:"DynamicDomesticValue"`
-		DynamicOverseasValue string `json:"DynamicOverseasValue"`
-		StaticValue          string `json:"StaticValue"`
-		StaticDomesticValue  string `json:"StaticDomesticValue"`
-		StaticOverseasValue  string `json:"StaticOverseasValue"`
-		L2Value              string `json:"L2Value"`
-		DomesticL2Value      string `json:"DomesticL2Value"`
-		OverseasL2Value      string `json:"OverseasL2Value"`
-	} `json:"BpsDataPerInterval"`
-	SupplyBpsDatas []struct {
-		TimeStamp string `json:"TimeStamp"`
-		Value     string `json:"Value"`
-	} `json:"SupplyBpsDatas"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
+            StartTime     string `json:"StartTime" xml:"StartTime"`
+            EndTime     string `json:"EndTime" xml:"EndTime"`
+            LocationNameEn     string `json:"LocationNameEn" xml:"LocationNameEn"`
+            IspNameEn     string `json:"IspNameEn" xml:"IspNameEn"`
+            LocationName     string `json:"LocationName" xml:"LocationName"`
+            IspName     string `json:"IspName" xml:"IspName"`
+                BpsDataPerInterval struct {
+                    DataModule []struct {
+            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
+            Value     string `json:"Value" xml:"Value"`
+            DomesticValue     string `json:"DomesticValue" xml:"DomesticValue"`
+            OverseasValue     string `json:"OverseasValue" xml:"OverseasValue"`
+            DynamicValue     string `json:"DynamicValue" xml:"DynamicValue"`
+            DynamicDomesticValue     string `json:"DynamicDomesticValue" xml:"DynamicDomesticValue"`
+            DynamicOverseasValue     string `json:"DynamicOverseasValue" xml:"DynamicOverseasValue"`
+            StaticValue     string `json:"StaticValue" xml:"StaticValue"`
+            StaticDomesticValue     string `json:"StaticDomesticValue" xml:"StaticDomesticValue"`
+            StaticOverseasValue     string `json:"StaticOverseasValue" xml:"StaticOverseasValue"`
+            L2Value     string `json:"L2Value" xml:"L2Value"`
+            DomesticL2Value     string `json:"DomesticL2Value" xml:"DomesticL2Value"`
+            OverseasL2Value     string `json:"OverseasL2Value" xml:"OverseasL2Value"`
+                    }   `json:"DataModule" xml:"DataModule"`
+                } `json:"BpsDataPerInterval" xml:"BpsDataPerInterval"`
+                SupplyBpsDatas struct {
+                    DataModule []struct {
+            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
+            Value     string `json:"Value" xml:"Value"`
+                    }   `json:"DataModule" xml:"DataModule"`
+                } `json:"SupplyBpsDatas" xml:"SupplyBpsDatas"`
 }
 
 func CreateDescribeDomainBpsDataRequest() (request *DescribeDomainBpsDataRequest) {
-	request = &DescribeDomainBpsDataRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainBpsData", "", "")
-	return
+request = &DescribeDomainBpsDataRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainBpsData", "", "")
+return
 }
 
 func CreateDescribeDomainBpsDataResponse() (response *DescribeDomainBpsDataResponse) {
-	response = &DescribeDomainBpsDataResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeDomainBpsDataResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/describe_domain_bps_data_by_time_stamp.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,87 +17,89 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainBpsDataByTimeStamp(request *DescribeDomainBpsDataByTimeStampRequest) (response *DescribeDomainBpsDataByTimeStampResponse, err error) {
-	response = CreateDescribeDomainBpsDataByTimeStampResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeDomainBpsDataByTimeStampResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeDomainBpsDataByTimeStampWithChan(request *DescribeDomainBpsDataByTimeStampRequest) (<-chan *DescribeDomainBpsDataByTimeStampResponse, <-chan error) {
-	responseChan := make(chan *DescribeDomainBpsDataByTimeStampResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeDomainBpsDataByTimeStamp(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeDomainBpsDataByTimeStampResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeDomainBpsDataByTimeStamp(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainBpsDataByTimeStampWithCallback(request *DescribeDomainBpsDataByTimeStampRequest, callback func(response *DescribeDomainBpsDataByTimeStampResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeDomainBpsDataByTimeStampResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeDomainBpsDataByTimeStamp(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeDomainBpsDataByTimeStampWithCallback(request *DescribeDomainBpsDataByTimeStampRequest, callback func(response *DescribeDomainBpsDataByTimeStampResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeDomainBpsDataByTimeStampResponse
+var err error
+defer close(result)
+response, err = client.DescribeDomainBpsDataByTimeStamp(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeDomainBpsDataByTimeStampRequest struct {
-	*requests.RpcRequest
-	IspNames      string `position:"Query" name:"IspNames"`
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	LocationNames string `position:"Query" name:"LocationNames"`
-	DomainName    string `position:"Query" name:"DomainName"`
-	Action        string `position:"Query" name:"Action"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
-	TimePoint     string `position:"Query" name:"TimePoint"`
+*requests.RpcRequest
+                IspNames  string `position:"Query" name:"IspNames"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                LocationNames  string `position:"Query" name:"LocationNames"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
+                TimePoint  string `position:"Query" name:"TimePoint"`
 }
 
+
 type DescribeDomainBpsDataByTimeStampResponse struct {
-	*responses.BaseResponse
-	RequestId   string `json:"RequestId"`
-	DomainName  string `json:"DomainName"`
-	TimeStamp   string `json:"TimeStamp"`
-	BpsDataList []struct {
-		LocationName string `json:"LocationName"`
-		IspName      string `json:"IspName"`
-		Bps          int64  `json:"Bps"`
-	} `json:"BpsDataList"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
+                BpsDataList struct {
+                    BpsDataModel []struct {
+            LocationName     string `json:"LocationName" xml:"LocationName"`
+            IspName     string `json:"IspName" xml:"IspName"`
+            Bps     int64 `json:"Bps" xml:"Bps"`
+                    }   `json:"BpsDataModel" xml:"BpsDataModel"`
+                } `json:"BpsDataList" xml:"BpsDataList"`
 }
 
 func CreateDescribeDomainBpsDataByTimeStampRequest() (request *DescribeDomainBpsDataByTimeStampRequest) {
-	request = &DescribeDomainBpsDataByTimeStampRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainBpsDataByTimeStamp", "", "")
-	return
+request = &DescribeDomainBpsDataByTimeStampRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainBpsDataByTimeStamp", "", "")
+return
 }
 
 func CreateDescribeDomainBpsDataByTimeStampResponse() (response *DescribeDomainBpsDataByTimeStampResponse) {
-	response = &DescribeDomainBpsDataByTimeStampResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeDomainBpsDataByTimeStampResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+

services/cdn/describe_domain_c_c_attack_info.go

@@ -1,3 +1,4 @@
+
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,92 +17,96 @@ package cdn
 // Changes may cause incorrect behavior and will be lost if the code is regenerated.
 
 import (
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainCCAttackInfo(request *DescribeDomainCCAttackInfoRequest) (response *DescribeDomainCCAttackInfoResponse, err error) {
-	response = CreateDescribeDomainCCAttackInfoResponse()
-	err = client.DoAction(request, response)
-	return
+response = CreateDescribeDomainCCAttackInfoResponse()
+err = client.DoAction(request, response)
+return
 }
 
 func (client *Client) DescribeDomainCCAttackInfoWithChan(request *DescribeDomainCCAttackInfoRequest) (<-chan *DescribeDomainCCAttackInfoResponse, <-chan error) {
-	responseChan := make(chan *DescribeDomainCCAttackInfoResponse, 1)
-	errChan := make(chan error, 1)
-	err := client.AddAsyncTask(func() {
-		defer close(responseChan)
-		defer close(errChan)
-		response, err := client.DescribeDomainCCAttackInfo(request)
-		responseChan <- response
-		errChan <- err
-	})
-	if err != nil {
-		errChan <- err
-		close(responseChan)
-		close(errChan)
-	}
-	return responseChan, errChan
+responseChan := make(chan *DescribeDomainCCAttackInfoResponse, 1)
+errChan := make(chan error, 1)
+err := client.AddAsyncTask(func() {
+defer close(responseChan)
+defer close(errChan)
+response, err :=  client.DescribeDomainCCAttackInfo(request)
+responseChan <- response
+errChan <- err
+})
+if err != nil {
+errChan <- err
+close(responseChan)
+close(errChan)
+}
+return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainCCAttackInfoWithCallback(request *DescribeDomainCCAttackInfoRequest, callback func(response *DescribeDomainCCAttackInfoResponse, err error)) <-chan int {
-	result := make(chan int, 1)
-	err := client.AddAsyncTask(func() {
-		var response *DescribeDomainCCAttackInfoResponse
-		var err error
-		defer close(result)
-		response, err = client.DescribeDomainCCAttackInfo(request)
-		callback(response, err)
-		result <- 1
-	})
-	if err != nil {
-		defer close(result)
-		callback(nil, err)
-		result <- 0
-	}
-	return result
+func (client *Client) DescribeDomainCCAttackInfoWithCallback(request *DescribeDomainCCAttackInfoRequest, callback func(response *DescribeDomainCCAttackInfoResponse, err error)) (<-chan int) {
+result := make(chan int, 1)
+err := client.AddAsyncTask(func() {
+var response *DescribeDomainCCAttackInfoResponse
+var err error
+defer close(result)
+response, err = client.DescribeDomainCCAttackInfo(request)
+callback(response, err)
+result <- 1
+})
+if err != nil {
+defer close(result)
+callback(nil, err)
+result <- 0
+}
+return result
 }
 
 type DescribeDomainCCAttackInfoRequest struct {
-	*requests.RpcRequest
-	SecurityToken string `position:"Query" name:"SecurityToken"`
-	DomainName    string `position:"Query" name:"DomainName"`
-	Action        string `position:"Query" name:"Action"`
-	EndTime       string `position:"Query" name:"EndTime"`
-	StartTime     string `position:"Query" name:"StartTime"`
-	OwnerId       string `position:"Query" name:"OwnerId"`
-	AccessKeyId   string `position:"Query" name:"AccessKeyId"`
+*requests.RpcRequest
+                EndTime  string `position:"Query" name:"EndTime"`
+                StartTime  string `position:"Query" name:"StartTime"`
+                DomainName  string `position:"Query" name:"DomainName"`
+                OwnerId  string `position:"Query" name:"OwnerId"`
+                SecurityToken  string `position:"Query" name:"SecurityToken"`
 }
 
+
 type DescribeDomainCCAttackInfoResponse struct {
-	*responses.BaseResponse
-	RequestId        string `json:"RequestId"`
-	DomainName       string `json:"DomainName"`
-	StartTime        string `json:"StartTime"`
-	EndTime          string `json:"EndTime"`
-	AttackIpDataList []struct {
-		Ip          string `json:"Ip"`
-		AttackCount string `json:"AttackCount"`
-		Result      string `json:"Result"`
-	} `json:"AttackIpDataList"`
-	AttackedUrlDataList []struct {
-		Url         string `json:"Url"`
-		AttackCount string `json:"AttackCount"`
-		Result      string `json:"Result"`
-	} `json:"AttackedUrlDataList"`
+*responses.BaseResponse
+            RequestId     string `json:"RequestId" xml:"RequestId"`
+            DomainName     string `json:"DomainName" xml:"DomainName"`
+            StartTime     string `json:"StartTime" xml:"StartTime"`
+            EndTime     string `json:"EndTime" xml:"EndTime"`
+                AttackIpDataList struct {
+                    AttackIpDatas []struct {
+            Ip     string `json:"Ip" xml:"Ip"`
+            AttackCount     string `json:"AttackCount" xml:"AttackCount"`
+            Result     string `json:"Result" xml:"Result"`
+                    }   `json:"AttackIpDatas" xml:"AttackIpDatas"`
+                } `json:"AttackIpDataList" xml:"AttackIpDataList"`
+                AttackedUrlDataList struct {
+                    AttackedUrlDatas []struct {
+            Url     string `json:"Url" xml:"Url"`
+            AttackCount     string `json:"AttackCount" xml:"AttackCount"`
+            Result     string `json:"Result" xml:"Result"`
+                    }   `json:"AttackedUrlDatas" xml:"AttackedUrlDatas"`
+                } `json:"AttackedUrlDataList" xml:"AttackedUrlDataList"`
 }
 
 func CreateDescribeDomainCCAttackInfoRequest() (request *DescribeDomainCCAttackInfoRequest) {
-	request = &DescribeDomainCCAttackInfoRequest{
-		RpcRequest: &requests.RpcRequest{},
-	}
-	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainCCAttackInfo", "", "")
-	return
+request = &DescribeDomainCCAttackInfoRequest{
+RpcRequest: &requests.RpcRequest{},
+}
+request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainCCAttackInfo", "", "")
+return
 }
 
 func CreateDescribeDomainCCAttackInfoResponse() (response *DescribeDomainCCAttackInfoResponse) {
-	response = &DescribeDomainCCAttackInfoResponse{
-		BaseResponse: &responses.BaseResponse{},
-	}
-	return
+response = &DescribeDomainCCAttackInfoResponse{
+BaseResponse: &responses.BaseResponse{},
+}
+return
 }
+