fix bugs

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

.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?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

@@ -9,10 +9,10 @@ func NewInteger(n int) Integer {
 }
 
 func (integer Integer) hasValue() bool {
-	return  integer != ""
+	return integer != ""
 }
 
-func (integer Integer) getValue() (int, error){
+func (integer Integer) getValue() (int, error) {
 	return strconv.Atoi(string(integer))
 }
 
@@ -23,10 +23,10 @@ func NewBoolean(bool bool) Boolean {
 }
 
 func (boolean Boolean) hasValue() bool {
-	return  boolean != ""
+	return boolean != ""
 }
 
-func (boolean Boolean) getValue() (bool, error){
+func (boolean Boolean) getValue() (bool, error) {
 	return strconv.ParseBool(string(boolean))
 }
 
@@ -37,9 +37,9 @@ func NewFloat(f float64) Float {
 }
 
 func (float Float) hasValue() bool {
-	return  float != ""
+	return float != ""
 }
 
-func (float Float) getValue() (float64, error){
+func (float Float) getValue() (float64, error) {
 	return strconv.ParseFloat(string(float), 64)
-}
+}

sdk/requests/types_test.go

@@ -1,8 +1,8 @@
 package requests
 
 import (
-	"testing"
 	"github.com/stretchr/testify/assert"
+	"testing"
 )
 
 func TestNewInteger(t *testing.T) {
@@ -28,4 +28,3 @@ func TestNewFloat(t *testing.T) {
 	assert.Nil(t, err)
 	assert.Equal(t, value, 123123.123123)
 }
-

sdk/responses/response.go

@@ -18,11 +18,11 @@ import (
 	"bytes"
 	"encoding/json"
 	"encoding/xml"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
 	"io/ioutil"
 	"net/http"
 	"strconv"
 	"strings"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
 )
 
 type AcsResponse interface {

services/alidns/add_batch_domain_records.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,86 +16,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) 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,79 +16,77 @@ 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,84 +16,82 @@ 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,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) 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,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) 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,81 +16,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) 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   request.Boolean `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,28 +16,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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,81 +16,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) 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,87 +16,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) 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        request.Integer `json:"Status" xml:"Status"`
+	BatchCount    request.Integer `json:"BatchCount" xml:"BatchCount"`
+	SuccessNumber request.Integer `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,90 +16,88 @@ 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    request.Integer `json:"TotalCount" xml:"TotalCount"`
+	PageNumber    request.Integer `json:"PageNumber" xml:"PageNumber"`
+	PageSize      request.Integer `json:"PageSize" xml:"PageSize"`
+	SlbSubDomains struct {
+		SlbSubDomain []struct {
+			SubDomain   string          `json:"SubDomain" xml:"SubDomain"`
+			RecordCount request.Integer `json:"RecordCount" xml:"RecordCount"`
+			Open        request.Boolean `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,108 +16,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) 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        request.Integer `json:"StartTimestamp" xml:"StartTimestamp"`
+	EndTime               string          `json:"EndTime" xml:"EndTime"`
+	EndTimestamp          request.Integer `json:"EndTimestamp" xml:"EndTimestamp"`
+	Domain                string          `json:"Domain" xml:"Domain"`
+	BindCount             request.Integer `json:"BindCount" xml:"BindCount"`
+	BindUsedCount         request.Integer `json:"BindUsedCount" xml:"BindUsedCount"`
+	TTLMinValue           request.Integer `json:"TTLMinValue" xml:"TTLMinValue"`
+	SubDomainLevel        request.Integer `json:"SubDomainLevel" xml:"SubDomainLevel"`
+	DnsSLBCount           request.Integer `json:"DnsSLBCount" xml:"DnsSLBCount"`
+	URLForwardCount       request.Integer `json:"URLForwardCount" xml:"URLForwardCount"`
+	DDosDefendFlow        request.Integer `json:"DDosDefendFlow" xml:"DDosDefendFlow"`
+	DDosDefendQuery       request.Integer `json:"DDosDefendQuery" xml:"DDosDefendQuery"`
+	OverseaDDosDefendFlow request.Integer `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      request.Integer `json:"MonitorNodeCount" xml:"MonitorNodeCount"`
+	MonitorFrequency      request.Integer `json:"MonitorFrequency" xml:"MonitorFrequency"`
+	MonitorTaskCount      request.Integer `json:"MonitorTaskCount" xml:"MonitorTaskCount"`
+	RegionLines           request.Boolean `json:"RegionLines" xml:"RegionLines"`
+	Gslb                  request.Boolean `json:"Gslb" xml:"Gslb"`
+	InClean               request.Boolean `json:"InClean" xml:"InClean"`
+	InBlackHole           request.Boolean `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,114 +16,112 @@ 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  request.Integer `json:"TotalCount" xml:"TotalCount"`
+	PageNumber  request.Integer `json:"PageNumber" xml:"PageNumber"`
+	PageSize    request.Integer `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        request.Integer `json:"StartTimestamp" xml:"StartTimestamp"`
+			EndTimestamp          request.Integer `json:"EndTimestamp" xml:"EndTimestamp"`
+			Domain                string          `json:"Domain" xml:"Domain"`
+			BindCount             request.Integer `json:"BindCount" xml:"BindCount"`
+			BindUsedCount         request.Integer `json:"BindUsedCount" xml:"BindUsedCount"`
+			TTLMinValue           request.Integer `json:"TTLMinValue" xml:"TTLMinValue"`
+			SubDomainLevel        request.Integer `json:"SubDomainLevel" xml:"SubDomainLevel"`
+			DnsSLBCount           request.Integer `json:"DnsSLBCount" xml:"DnsSLBCount"`
+			URLForwardCount       request.Integer `json:"URLForwardCount" xml:"URLForwardCount"`
+			DDosDefendFlow        request.Integer `json:"DDosDefendFlow" xml:"DDosDefendFlow"`
+			DDosDefendQuery       request.Integer `json:"DDosDefendQuery" xml:"DDosDefendQuery"`
+			OverseaDDosDefendFlow request.Integer `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      request.Integer `json:"MonitorNodeCount" xml:"MonitorNodeCount"`
+			MonitorFrequency      request.Integer `json:"MonitorFrequency" xml:"MonitorFrequency"`
+			MonitorTaskCount      request.Integer `json:"MonitorTaskCount" xml:"MonitorTaskCount"`
+			RegionLines           request.Boolean `json:"RegionLines" xml:"RegionLines"`
+			Gslb                  request.Boolean `json:"Gslb" xml:"Gslb"`
+			InClean               request.Boolean `json:"InClean" xml:"InClean"`
+			InBlackHole           request.Boolean `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,89 +16,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) 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   request.Integer `json:"TotalCount" xml:"TotalCount"`
+	PageNumber   request.Integer `json:"PageNumber" xml:"PageNumber"`
+	PageSize     request.Integer `json:"PageSize" xml:"PageSize"`
+	DomainGroups struct {
+		DomainGroup []struct {
+			GroupId     string          `json:"GroupId" xml:"GroupId"`
+			GroupName   string          `json:"GroupName" xml:"GroupName"`
+			DomainCount request.Integer `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,106 +16,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) 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          request.Boolean `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             request.Integer `json:"MinTtl" xml:"MinTtl"`
+	RecordLineTreeJson string          `json:"RecordLineTreeJson" xml:"RecordLineTreeJson"`
+	LineType           string          `json:"LineType" xml:"LineType"`
+	RegionLines        request.Boolean `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,95 +16,93 @@ 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 request.Integer `json:"TotalCount" xml:"TotalCount"`
+	PageNumber request.Integer `json:"PageNumber" xml:"PageNumber"`
+	PageSize   request.Integer `json:"PageSize" xml:"PageSize"`
+	DomainLogs struct {
+		DomainLog []struct {
+			ActionTime      string          `json:"ActionTime" xml:"ActionTime"`
+			ActionTimestamp request.Integer `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,85 +16,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) 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     request.Boolean `json:"AllAliDns" xml:"AllAliDns"`
+	IncludeAliDns request.Boolean `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,91 +16,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) 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        request.Integer `json:"TTL" xml:"TTL"`
+	Priority   request.Integer `json:"Priority" xml:"Priority"`
+	Line       string          `json:"Line" xml:"Line"`
+	Status     string          `json:"Status" xml:"Status"`
+	Locked     request.Boolean `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,104 +16,102 @@ 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"`
-                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"`
+	*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    request.Integer `json:"TotalCount" xml:"TotalCount"`
+	PageNumber    request.Integer `json:"PageNumber" xml:"PageNumber"`
+	PageSize      request.Integer `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        request.Integer `json:"TTL" xml:"TTL"`
+			Priority   request.Integer `json:"Priority" xml:"Priority"`
+			Line       string          `json:"Line" xml:"Line"`
+			Status     string          `json:"Status" xml:"Status"`
+			Locked     request.Boolean `json:"Locked" xml:"Locked"`
+			Weight     request.Integer `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,89 +16,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) 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,104 +16,102 @@ 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 request.Integer `json:"TotalCount" xml:"TotalCount"`
+	PageNumber request.Integer `json:"PageNumber" xml:"PageNumber"`
+	PageSize   request.Integer `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       request.Boolean `json:"AliDomain" xml:"AliDomain"`
+			RecordCount     request.Integer `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 request.Boolean `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,94 +16,92 @@ 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 request.Integer `json:"TotalCount" xml:"TotalCount"`
+	PageNumber request.Integer `json:"PageNumber" xml:"PageNumber"`
+	PageSize   request.Integer `json:"PageSize" xml:"PageSize"`
+	RecordLogs struct {
+		RecordLog []struct {
+			ActionTime      string          `json:"ActionTime" xml:"ActionTime"`
+			ActionTimestamp request.Integer `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,98 +16,96 @@ 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    request.Integer `json:"TotalCount" xml:"TotalCount"`
+	PageNumber    request.Integer `json:"PageNumber" xml:"PageNumber"`
+	PageSize      request.Integer `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        request.Integer `json:"TTL" xml:"TTL"`
+			Priority   request.Integer `json:"Priority" xml:"Priority"`
+			Line       string          `json:"Line" xml:"Line"`
+			Status     string          `json:"Status" xml:"Status"`
+			Locked     request.Boolean `json:"Locked" xml:"Locked"`
+			Weight     request.Integer `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,84 +16,82 @@ 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,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) 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 request.Integer `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,83 +16,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) 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,79 +16,77 @@ 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,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) 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 request.Integer `json:"RecordCount" xml:"RecordCount"`
+	Open        request.Boolean `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,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) 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,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) 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    request.Integer `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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,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) 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,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,84 +16,82 @@ 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,4 +1,3 @@
-
 package arms
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,103 +16,102 @@ 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
-                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"`
+	*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 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 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" xml:"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,4 +1,3 @@
-
 package arms
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,28 +16,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,4 +1,3 @@
-
 package arms
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,92 +16,91 @@ 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
-                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"`
+	*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" xml:"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,4 +1,3 @@
-
 package arms4finance
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,86 +16,85 @@ 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
-                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"`
+	*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" xml:"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,4 +1,3 @@
-
 package arms4finance
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,28 +16,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,4 +1,3 @@
-
 package arms4finance
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,88 +16,87 @@ 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
-                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"`
+	*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" xml:"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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,100 +16,98 @@ 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
-                PhoneNumber  string `position:"Query" name:"PhoneNumber"`
-                Usage  string `position:"Query" name:"Usage"`
-                ContactFlowId  string `position:"Query" name:"ContactFlowId"`
-                InstanceId  string `position:"Query" name:"InstanceId"`
+	*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" 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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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               request.Boolean `json:"TestOnly" xml:"TestOnly"`
+		RemainingTime          request.Integer `json:"RemainingTime" xml:"RemainingTime"`
+		AllowOutbound          request.Boolean `json:"AllowOutbound" xml:"AllowOutbound"`
+		Usage                  string          `json:"Usage" xml:"Usage"`
+		Trunks                 request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,83 +16,81 @@ 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"`
-                RoleId  *[]string `position:"Query" name:"RoleId"  type:"Repeated"`
-                SkillGroupId  *[]string `position:"Query" name:"SkillGroupId"  type:"Repeated"`
-                InstanceId  string `position:"Query" name:"InstanceId"`
+	*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" 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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,28 +16,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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,85 +16,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) 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"`
-                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"`
+	*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" 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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,87 +16,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) 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
-                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"`
+	*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" 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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,78 @@ 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
-                SkillGroupId  string `position:"Query" name:"SkillGroupId"`
-                InstanceId  string `position:"Query" name:"InstanceId"`
+	*requests.RpcRequest
+	SkillGroupId string `position:"Query" name:"SkillGroupId"`
+	InstanceId   string `position:"Query" name:"InstanceId"`
 }
 
-
 type DeleteSkillGroupResponse struct {
-*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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,86 +16,84 @@ 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
-                ObjectType  string `position:"Query" name:"ObjectType"`
-                Name  string `position:"Query" name:"Name"`
-                ObjectId  string `position:"Query" name:"ObjectId"`
-                InstanceId  string `position:"Query" name:"InstanceId"`
+	*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" 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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,86 +16,84 @@ 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"`
+	*requests.RpcRequest
+	ServiceType string `position:"Query" name:"ServiceType"`
+	InstanceId  string `position:"Query" name:"InstanceId"`
 }
 
-
 type GetServiceExtensionsResponse struct {
-*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"`
+	*responses.BaseResponse
+	RequestId         string          `json:"RequestId" xml:"RequestId"`
+	Success           request.Boolean `json:"Success" xml:"Success"`
+	Code              string          `json:"Code" xml:"Code"`
+	Message           string          `json:"Message" xml:"Message"`
+	HttpStatusCode    request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,112 +16,110 @@ 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
-                UserId  string `position:"Query" name:"UserId"`
-                InstanceId  string `position:"Query" name:"InstanceId"`
+	*requests.RpcRequest
+	UserId     string `position:"Query" name:"UserId"`
+	InstanceId string `position:"Query" name:"InstanceId"`
 }
 
-
 type GetUserResponse struct {
-*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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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        request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,113 +16,111 @@ 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"`
+	*requests.RpcRequest
+	InstanceId string `position:"Query" name:"InstanceId"`
 }
 
-
 type ListContactFlowsResponse struct {
-*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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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               request.Boolean `json:"TestOnly" xml:"TestOnly"`
+					RemainingTime          request.Integer `json:"RemainingTime" xml:"RemainingTime"`
+					AllowOutbound          request.Boolean `json:"AllowOutbound" xml:"AllowOutbound"`
+					Usage                  string          `json:"Usage" xml:"Usage"`
+					Trunks                 request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,100 +16,98 @@ 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"`
+	*requests.RpcRequest
+	OutboundOnly string `position:"Query" name:"OutboundOnly"`
+	InstanceId   string `position:"Query" name:"InstanceId"`
 }
 
-
 type ListPhoneNumbersResponse struct {
-*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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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               request.Boolean `json:"TestOnly" xml:"TestOnly"`
+			RemainingTime          request.Integer `json:"RemainingTime" xml:"RemainingTime"`
+			AllowOutbound          request.Boolean `json:"AllowOutbound" xml:"AllowOutbound"`
+			Usage                  string          `json:"Usage" xml:"Usage"`
+			Trunks                 request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,87 +16,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) 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"`
+	*requests.RpcRequest
+	InstanceId string `position:"Query" name:"InstanceId"`
 }
 
-
 type ListRolesResponse struct {
-*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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,103 +16,101 @@ 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"`
+	*requests.RpcRequest
+	InstanceId string `position:"Query" name:"InstanceId"`
 }
 
-
 type ListSkillGroupsResponse struct {
-*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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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             request.Integer `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               request.Boolean `json:"TestOnly" xml:"TestOnly"`
+					RemainingTime          request.Integer `json:"RemainingTime" xml:"RemainingTime"`
+					AllowOutbound          request.Boolean `json:"AllowOutbound" xml:"AllowOutbound"`
+					Usage                  string          `json:"Usage" xml:"Usage"`
+					Trunks                 request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,105 +16,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) 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
-                UserId  string `position:"Query" name:"UserId"`
-                InstanceId  string `position:"Query" name:"InstanceId"`
+	*requests.RpcRequest
+	UserId     string `position:"Query" name:"UserId"`
+	InstanceId string `position:"Query" name:"InstanceId"`
 }
 
-
 type ListSkillGroupsOfUserResponse struct {
-*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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `json:"HttpStatusCode" xml:"HttpStatusCode"`
+	SkillLevels    struct {
+		SkillLevel []struct {
+			SkillLevelId string          `json:"SkillLevelId" xml:"SkillLevelId"`
+			Level        request.Integer `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               request.Boolean `json:"TestOnly" xml:"TestOnly"`
+						RemainingTime          request.Integer `json:"RemainingTime" xml:"RemainingTime"`
+						AllowOutbound          request.Boolean `json:"AllowOutbound" xml:"AllowOutbound"`
+						Usage                  string          `json:"Usage" xml:"Usage"`
+						Trunks                 request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,121 +16,119 @@ 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
-                PageSize  string `position:"Query" name:"PageSize"`
-                PageNumber  string `position:"Query" name:"PageNumber"`
-                InstanceId  string `position:"Query" name:"InstanceId"`
+	*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" 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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `json:"HttpStatusCode" xml:"HttpStatusCode"`
+	Users          struct {
+		TotalCount request.Integer `json:"TotalCount" xml:"TotalCount"`
+		PageNumber request.Integer `json:"PageNumber" xml:"PageNumber"`
+		PageSize   request.Integer `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    request.Boolean `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        request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,129 +16,127 @@ 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
-                PageSize  string `position:"Query" name:"PageSize"`
-                PageNumber  string `position:"Query" name:"PageNumber"`
-                SkillGroupId  string `position:"Query" name:"SkillGroupId"`
-                InstanceId  string `position:"Query" name:"InstanceId"`
+	*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" 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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `json:"HttpStatusCode" xml:"HttpStatusCode"`
+	Users          struct {
+		TotalCount request.Integer `json:"TotalCount" xml:"TotalCount"`
+		PageNumber request.Integer `json:"PageNumber" xml:"PageNumber"`
+		PageSize   request.Integer `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       request.Integer `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        request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,100 +16,98 @@ 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
-                PhoneNumberId  string `position:"Query" name:"PhoneNumberId"`
-                Usage  string `position:"Query" name:"Usage"`
-                ContactFlowId  string `position:"Query" name:"ContactFlowId"`
-                InstanceId  string `position:"Query" name:"InstanceId"`
+	*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" 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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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               request.Boolean `json:"TestOnly" xml:"TestOnly"`
+		RemainingTime          request.Integer `json:"RemainingTime" xml:"RemainingTime"`
+		AllowOutbound          request.Boolean `json:"AllowOutbound" xml:"AllowOutbound"`
+		Usage                  string          `json:"Usage" xml:"Usage"`
+		Trunks                 request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,85 +16,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) 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"`
-                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"`
+	*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" 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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,86 +16,84 @@ 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
-                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"`
+	*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" 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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,83 +16,81 @@ 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"`
+	*requests.RpcRequest
+	InstanceId string `position:"Query" name:"InstanceId"`
 }
 
-
 type RefreshTokenResponse struct {
-*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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,78 @@ 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
-                PhoneNumberId  string `position:"Query" name:"PhoneNumberId"`
-                InstanceId  string `position:"Query" name:"InstanceId"`
+	*requests.RpcRequest
+	PhoneNumberId string `position:"Query" name:"PhoneNumberId"`
+	InstanceId    string `position:"Query" name:"InstanceId"`
 }
 
-
 type RemovePhoneNumberResponse struct {
-*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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,78 @@ 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
-                UserId  *[]string `position:"Query" name:"UserId"  type:"Repeated"`
-                InstanceId  string `position:"Query" name:"InstanceId"`
+	*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" 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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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,4 +1,3 @@
-
 package ccc
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,90 +16,88 @@ 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"`
+	*requests.RpcRequest
+	InstanceId string `position:"Query" name:"InstanceId"`
 }
 
-
 type RequestLoginInfoResponse struct {
-*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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	Success        request.Boolean `json:"Success" xml:"Success"`
+	Code           string          `json:"Code" xml:"Code"`
+	Message        string          `json:"Message" xml:"Message"`
+	HttpStatusCode request.Integer `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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,89 +16,87 @@ 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
-                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"`
+	*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" xml:"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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,81 +16,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) 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"`
-                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"`
+	*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" xml:"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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,83 +16,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) 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"`
-                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"`
+	*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" xml:"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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ 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"`
-                PushDomain  string `position:"Query" name:"PushDomain"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*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" xml:"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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,82 +16,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) 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
-                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"`
+	*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" xml:"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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,82 +16,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) 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"`
-                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"`
+	*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" xml:"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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,94 +16,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) 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
-                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"`
+	*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" 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"`
+	*responses.BaseResponse
+	RequestId  string          `json:"RequestId" xml:"RequestId"`
+	PageNumber request.Integer `json:"PageNumber" xml:"PageNumber"`
+	PageSize   request.Integer `json:"PageSize" xml:"PageSize"`
+	TotalCount request.Integer `json:"TotalCount" xml:"TotalCount"`
+	BpsDatas   struct {
+		DataModule []struct {
+			Timestamp  string        `json:"Timestamp" xml:"Timestamp"`
+			L1Bps      request.Float `json:"L1Bps" xml:"L1Bps"`
+			L1InnerBps request.Float `json:"L1InnerBps" xml:"L1InnerBps"`
+			L1OutBps   request.Float `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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,77 +16,75 @@ 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
-                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*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" xml:"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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ 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
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*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" xml:"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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,28 +16,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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,92 +16,90 @@ 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
-                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"`
+	*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" 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"`
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	RecordInfo struct {
+		RecordId   string          `json:"RecordId" xml:"RecordId"`
+		RecordUrl  string          `json:"RecordUrl" xml:"RecordUrl"`
+		Duration   request.Float   `json:"Duration" xml:"Duration"`
+		Height     request.Integer `json:"Height" xml:"Height"`
+		Width      request.Integer `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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ 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
-                DomainName  string `position:"Query" name:"DomainName"`
-                ResourceGroupId  string `position:"Query" name:"ResourceGroupId"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*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" xml:"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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ 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
-                DomainName  string `position:"Query" name:"DomainName"`
-                ConfigID  string `position:"Query" name:"ConfigID"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*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" xml:"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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ 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
-                DomainName  string `position:"Query" name:"DomainName"`
-                AppName  string `position:"Query" name:"AppName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*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" xml:"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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ 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
-                DomainName  string `position:"Query" name:"DomainName"`
-                AppName  string `position:"Query" name:"AppName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*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" xml:"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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ 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"`
-                PushDomain  string `position:"Query" name:"PushDomain"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*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" xml:"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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,79 +16,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) 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
-                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"`
+	*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" xml:"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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,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) 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"`
-                Domain  string `position:"Query" name:"Domain"`
-                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*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" xml:"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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,91 +16,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) 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
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*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" 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"`
+	*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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,107 +16,105 @@ 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
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*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" 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"`
+	*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              request.Integer `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     request.Integer `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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,97 +16,95 @@ 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
-                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"`
+	*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" 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"`
+	*responses.BaseResponse
+	RequestId      string          `json:"RequestId" xml:"RequestId"`
+	PageNumber     request.Integer `json:"PageNumber" xml:"PageNumber"`
+	PageSize       request.Integer `json:"PageSize" xml:"PageSize"`
+	TotalCount     request.Integer `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   request.Integer `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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,94 +16,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) 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
-                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"`
+	*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" 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"`
+	*responses.BaseResponse
+	RequestId       string          `json:"RequestId" xml:"RequestId"`
+	DomainName      string          `json:"DomainName" xml:"DomainName"`
+	MonitorInterval request.Integer `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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,88 +16,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) 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
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeCdnRegionAndIspResponse struct {
-*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"`
+	*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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,86 +16,84 @@ 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
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeCdnServiceResponse struct {
-*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"`
+	*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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,83 +16,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) 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
-                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*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" 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"`
+	*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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,91 +16,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) 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
-                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"`
+	*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" 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"`
+	*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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,116 +16,114 @@ 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
-                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"`
+	*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" 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"`
+	*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,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,89 +16,87 @@ 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"`
-                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"`
+	*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" 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"`
+	*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          request.Integer `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
 }
-