Support certificate translate.

CHANGELOG

@@ -1,3 +1,59 @@
+2020-03-11 Version: 1.36.314
+- Support certificate translate.
+
+2020-03-10 Version: 1.36.313
+- Add ExportTas apis.
+
+2020-03-10 Version: 1.36.312
+- Add ExportTas apis.
+
+2020-03-09 Version: 1.36.311
+- Add EmotionConfidence to GetImage.
+
+2020-03-09 Version: 1.36.310
+- Add BackupStorageType.
+
+2020-03-09 Version: 1.36.309
+- Add EmotionConfidence to GetImage.
+
+2020-03-09 Version: 1.36.308
+- Add EmotionConfidence to GetImage.
+
+2020-03-09 Version: 1.36.307
+- NlpAutoml update contract api.
+
+2020-03-09 Version: 1.36.306
+- NlpAutoml update contract api.
+
+2020-03-06 Version: 1.36.305
+- Supported Saf for cn.
+
+2020-03-06 Version: 1.36.304
+- Supported Saf for cn.
+
+2020-03-06 Version: 1.36.303
+- Supported Saf for oversea.
+
+2020-03-06 Version: 1.36.302
+- Add request parameter groupType for OnsGroupCreate.
+- Add request parameter groupType for OnsGroupList.
+
+2020-03-05 Version: 1.36.301
+- Add param InstanceType for ListImages and ListCustomImages.
+- Fix error codes for SubmitJobs and so on.
+
+2020-03-04 Version: 1.36.300
+- Update.
+
+2020-03-03 Version: 1.36.299
+- Supported secretmanager stable version for kms.
+
+2020-03-03 Version: 1.36.298
+- Supported secretmanager stable version for kms.
+
+2020-03-03 Version: 1.36.297
+- GeoIP Databases SDK initial release.
+
 2020-03-03 Version: 1.36.296
 - Supported secretmanager for kms.
 

VERSION

@@ -1 +1 @@
-1.36.296
+1.36.314

alimt/CMakeLists.txt

@@ -27,6 +27,8 @@ set(alimt_public_header_model
 	include/alibabacloud/alimt/model/GetDocTranslateTaskResult.h
 	include/alibabacloud/alimt/model/TranslateRequest.h
 	include/alibabacloud/alimt/model/TranslateResult.h
+	include/alibabacloud/alimt/model/TranslateCertificateRequest.h
+	include/alibabacloud/alimt/model/TranslateCertificateResult.h
 	include/alibabacloud/alimt/model/TranslateECommerceRequest.h
 	include/alibabacloud/alimt/model/TranslateECommerceResult.h
 	include/alibabacloud/alimt/model/TranslateGeneralRequest.h
@@ -40,6 +42,8 @@ set(alimt_src
 	src/model/GetDocTranslateTaskResult.cc
 	src/model/TranslateRequest.cc
 	src/model/TranslateResult.cc
+	src/model/TranslateCertificateRequest.cc
+	src/model/TranslateCertificateResult.cc
 	src/model/TranslateECommerceRequest.cc
 	src/model/TranslateECommerceResult.cc
 	src/model/TranslateGeneralRequest.cc

alimt/include/alibabacloud/alimt/AlimtClient.h

@@ -28,6 +28,8 @@
 #include "model/GetDocTranslateTaskResult.h"
 #include "model/TranslateRequest.h"
 #include "model/TranslateResult.h"
+#include "model/TranslateCertificateRequest.h"
+#include "model/TranslateCertificateResult.h"
 #include "model/TranslateECommerceRequest.h"
 #include "model/TranslateECommerceResult.h"
 #include "model/TranslateGeneralRequest.h"
@@ -50,6 +52,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::TranslateResult> TranslateOutcome;
 			typedef std::future<TranslateOutcome> TranslateOutcomeCallable;
 			typedef std::function<void(const AlimtClient*, const Model::TranslateRequest&, const TranslateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TranslateAsyncHandler;
+			typedef Outcome<Error, Model::TranslateCertificateResult> TranslateCertificateOutcome;
+			typedef std::future<TranslateCertificateOutcome> TranslateCertificateOutcomeCallable;
+			typedef std::function<void(const AlimtClient*, const Model::TranslateCertificateRequest&, const TranslateCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TranslateCertificateAsyncHandler;
 			typedef Outcome<Error, Model::TranslateECommerceResult> TranslateECommerceOutcome;
 			typedef std::future<TranslateECommerceOutcome> TranslateECommerceOutcomeCallable;
 			typedef std::function<void(const AlimtClient*, const Model::TranslateECommerceRequest&, const TranslateECommerceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TranslateECommerceAsyncHandler;
@@ -70,6 +75,9 @@ namespace AlibabaCloud
 			TranslateOutcome translate(const Model::TranslateRequest &request)const;
 			void translateAsync(const Model::TranslateRequest& request, const TranslateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			TranslateOutcomeCallable translateCallable(const Model::TranslateRequest& request) const;
+			TranslateCertificateOutcome translateCertificate(const Model::TranslateCertificateRequest &request)const;
+			void translateCertificateAsync(const Model::TranslateCertificateRequest& request, const TranslateCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TranslateCertificateOutcomeCallable translateCertificateCallable(const Model::TranslateCertificateRequest& request) const;
 			TranslateECommerceOutcome translateECommerce(const Model::TranslateECommerceRequest &request)const;
 			void translateECommerceAsync(const Model::TranslateECommerceRequest& request, const TranslateECommerceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			TranslateECommerceOutcomeCallable translateECommerceCallable(const Model::TranslateECommerceRequest& request) const;

alimt/include/alibabacloud/alimt/model/TranslateCertificateRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALIMT_MODEL_TRANSLATECERTIFICATEREQUEST_H_
+#define ALIBABACLOUD_ALIMT_MODEL_TRANSLATECERTIFICATEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alimt/AlimtExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alimt
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIMT_EXPORT TranslateCertificateRequest : public RpcServiceRequest
+			{
+
+			public:
+				TranslateCertificateRequest();
+				~TranslateCertificateRequest();
+
+				std::string getSourceLanguage()const;
+				void setSourceLanguage(const std::string& sourceLanguage);
+				std::string getCertificateType()const;
+				void setCertificateType(const std::string& certificateType);
+				std::string getResultType()const;
+				void setResultType(const std::string& resultType);
+				std::string getImageUrl()const;
+				void setImageUrl(const std::string& imageUrl);
+				std::string getTargetLanguage()const;
+				void setTargetLanguage(const std::string& targetLanguage);
+
+            private:
+				std::string sourceLanguage_;
+				std::string certificateType_;
+				std::string resultType_;
+				std::string imageUrl_;
+				std::string targetLanguage_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIMT_MODEL_TRANSLATECERTIFICATEREQUEST_H_

alimt/include/alibabacloud/alimt/model/TranslateCertificateResult.h

@@ -14,54 +14,49 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_IMM_MODEL_COMPAREFACERESULT_H_
-#define ALIBABACLOUD_IMM_MODEL_COMPAREFACERESULT_H_
+#ifndef ALIBABACLOUD_ALIMT_MODEL_TRANSLATECERTIFICATERESULT_H_
+#define ALIBABACLOUD_ALIMT_MODEL_TRANSLATECERTIFICATERESULT_H_
 
 #include <string>
 #include <vector>
 #include <utility>
 #include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/imm/ImmExport.h>
+#include <alibabacloud/alimt/AlimtExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Imm
+	namespace Alimt
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_IMM_EXPORT CompareFaceResult : public ServiceResult
+			class ALIBABACLOUD_ALIMT_EXPORT TranslateCertificateResult : public ServiceResult
 			{
 			public:
-				struct CompareResultItem
+				struct Data
 				{
-					struct FaceA
+					struct CertificateTranslateItemDTO
 					{
-						std::string imageUri;
-						std::vector<std::string> axis;
+						std::string valueTranslation;
+						std::string keyTranslation;
+						std::string value;
+						std::string key;
 					};
-					struct FaceB
-					{
-						std::string imageUri;
-						std::vector<std::string> axis1;
-					};
-					float similarity;
-					FaceA faceA;
-					FaceB faceB;
+					std::vector<CertificateTranslateItemDTO> translatedValues;
 				};
 
 
-				CompareFaceResult();
-				explicit CompareFaceResult(const std::string &payload);
-				~CompareFaceResult();
-				std::vector<CompareResultItem> getCompareResult()const;
+				TranslateCertificateResult();
+				explicit TranslateCertificateResult(const std::string &payload);
+				~TranslateCertificateResult();
+				Data getData()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::vector<CompareResultItem> compareResult_;
+				Data data_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_IMM_MODEL_COMPAREFACERESULT_H_
+#endif // !ALIBABACLOUD_ALIMT_MODEL_TRANSLATECERTIFICATERESULT_H_

alimt/src/AlimtClient.cc

@@ -31,21 +31,21 @@ AlimtClient::AlimtClient(const Credentials &credentials, const ClientConfigurati
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "alimt");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "alimtct");
 }
 
 AlimtClient::AlimtClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "alimt");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "alimtct");
 }
 
 AlimtClient::AlimtClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "alimt");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "alimtct");
 }
 
 AlimtClient::~AlimtClient()
@@ -159,6 +159,42 @@ AlimtClient::TranslateOutcomeCallable AlimtClient::translateCallable(const Trans
 	return task->get_future();
 }
 
+AlimtClient::TranslateCertificateOutcome AlimtClient::translateCertificate(const TranslateCertificateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return TranslateCertificateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return TranslateCertificateOutcome(TranslateCertificateResult(outcome.result()));
+	else
+		return TranslateCertificateOutcome(outcome.error());
+}
+
+void AlimtClient::translateCertificateAsync(const TranslateCertificateRequest& request, const TranslateCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, translateCertificate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlimtClient::TranslateCertificateOutcomeCallable AlimtClient::translateCertificateCallable(const TranslateCertificateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<TranslateCertificateOutcome()>>(
+			[this, request]()
+			{
+			return this->translateCertificate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AlimtClient::TranslateECommerceOutcome AlimtClient::translateECommerce(const TranslateECommerceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

alimt/src/model/CreateDocTranslateTaskRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Alimt::Model::CreateDocTranslateTaskRequest;
 CreateDocTranslateTaskRequest::CreateDocTranslateTaskRequest() :
 	RpcServiceRequest("alimt", "2018-10-12", "CreateDocTranslateTask")
 {
-	setMethod(HttpRequest::Method::POST);
+	setMethod(HttpRequest::Method::Post);
 }
 
 CreateDocTranslateTaskRequest::~CreateDocTranslateTaskRequest()

alimt/src/model/GetDocTranslateTaskRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Alimt::Model::GetDocTranslateTaskRequest;
 GetDocTranslateTaskRequest::GetDocTranslateTaskRequest() :
 	RpcServiceRequest("alimt", "2018-10-12", "GetDocTranslateTask")
 {
-	setMethod(HttpRequest::Method::GET);
+	setMethod(HttpRequest::Method::Get);
 }
 
 GetDocTranslateTaskRequest::~GetDocTranslateTaskRequest()

alimt/src/model/TranslateCertificateRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/alimt/model/TranslateCertificateRequest.h>
+
+using AlibabaCloud::Alimt::Model::TranslateCertificateRequest;
+
+TranslateCertificateRequest::TranslateCertificateRequest() :
+	RpcServiceRequest("alimt", "2018-10-12", "TranslateCertificate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+TranslateCertificateRequest::~TranslateCertificateRequest()
+{}
+
+std::string TranslateCertificateRequest::getSourceLanguage()const
+{
+	return sourceLanguage_;
+}
+
+void TranslateCertificateRequest::setSourceLanguage(const std::string& sourceLanguage)
+{
+	sourceLanguage_ = sourceLanguage;
+	setBodyParameter("SourceLanguage", sourceLanguage);
+}
+
+std::string TranslateCertificateRequest::getCertificateType()const
+{
+	return certificateType_;
+}
+
+void TranslateCertificateRequest::setCertificateType(const std::string& certificateType)
+{
+	certificateType_ = certificateType;
+	setBodyParameter("CertificateType", certificateType);
+}
+
+std::string TranslateCertificateRequest::getResultType()const
+{
+	return resultType_;
+}
+
+void TranslateCertificateRequest::setResultType(const std::string& resultType)
+{
+	resultType_ = resultType;
+	setBodyParameter("ResultType", resultType);
+}
+
+std::string TranslateCertificateRequest::getImageUrl()const
+{
+	return imageUrl_;
+}
+
+void TranslateCertificateRequest::setImageUrl(const std::string& imageUrl)
+{
+	imageUrl_ = imageUrl;
+	setBodyParameter("ImageUrl", imageUrl);
+}
+
+std::string TranslateCertificateRequest::getTargetLanguage()const
+{
+	return targetLanguage_;
+}
+
+void TranslateCertificateRequest::setTargetLanguage(const std::string& targetLanguage)
+{
+	targetLanguage_ = targetLanguage;
+	setBodyParameter("TargetLanguage", targetLanguage);
+}
+

alimt/src/model/TranslateCertificateResult.cc

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/alimt/model/TranslateCertificateResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alimt;
+using namespace AlibabaCloud::Alimt::Model;
+
+TranslateCertificateResult::TranslateCertificateResult() :
+	ServiceResult()
+{}
+
+TranslateCertificateResult::TranslateCertificateResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+TranslateCertificateResult::~TranslateCertificateResult()
+{}
+
+void TranslateCertificateResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto allTranslatedValuesNode = dataNode["TranslatedValues"]["CertificateTranslateItemDTO"];
+	for (auto dataNodeTranslatedValuesCertificateTranslateItemDTO : allTranslatedValuesNode)
+	{
+		Data::CertificateTranslateItemDTO certificateTranslateItemDTOObject;
+		if(!dataNodeTranslatedValuesCertificateTranslateItemDTO["Key"].isNull())
+			certificateTranslateItemDTOObject.key = dataNodeTranslatedValuesCertificateTranslateItemDTO["Key"].asString();
+		if(!dataNodeTranslatedValuesCertificateTranslateItemDTO["Value"].isNull())
+			certificateTranslateItemDTOObject.value = dataNodeTranslatedValuesCertificateTranslateItemDTO["Value"].asString();
+		if(!dataNodeTranslatedValuesCertificateTranslateItemDTO["ValueTranslation"].isNull())
+			certificateTranslateItemDTOObject.valueTranslation = dataNodeTranslatedValuesCertificateTranslateItemDTO["ValueTranslation"].asString();
+		if(!dataNodeTranslatedValuesCertificateTranslateItemDTO["KeyTranslation"].isNull())
+			certificateTranslateItemDTOObject.keyTranslation = dataNodeTranslatedValuesCertificateTranslateItemDTO["KeyTranslation"].asString();
+		data_.translatedValues.push_back(certificateTranslateItemDTOObject);
+	}
+
+}
+
+TranslateCertificateResult::Data TranslateCertificateResult::getData()const
+{
+	return data_;
+}
+

alimt/src/model/TranslateECommerceRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Alimt::Model::TranslateECommerceRequest;
 TranslateECommerceRequest::TranslateECommerceRequest() :
 	RpcServiceRequest("alimt", "2018-10-12", "TranslateECommerce")
 {
-	setMethod(HttpRequest::Method::POST);
+	setMethod(HttpRequest::Method::Post);
 }
 
 TranslateECommerceRequest::~TranslateECommerceRequest()

alimt/src/model/TranslateGeneralRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Alimt::Model::TranslateGeneralRequest;
 TranslateGeneralRequest::TranslateGeneralRequest() :
 	RpcServiceRequest("alimt", "2018-10-12", "TranslateGeneral")
 {
-	setMethod(HttpRequest::Method::POST);
+	setMethod(HttpRequest::Method::Post);
 }
 
 TranslateGeneralRequest::~TranslateGeneralRequest()

alimt/src/model/TranslateRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Alimt::Model::TranslateRequest;
 TranslateRequest::TranslateRequest() :
 	RpcServiceRequest("alimt", "2018-10-12", "Translate")
 {
-	setMethod(HttpRequest::Method::POST);
+	setMethod(HttpRequest::Method::Post);
 }
 
 TranslateRequest::~TranslateRequest()

cdn/CMakeLists.txt

@@ -49,6 +49,8 @@ set(cdn_public_header_model
 	include/alibabacloud/cdn/model/BatchUpdateCdnDomainResult.h
 	include/alibabacloud/cdn/model/CreateCdnCertificateSigningRequestRequest.h
 	include/alibabacloud/cdn/model/CreateCdnCertificateSigningRequestResult.h
+	include/alibabacloud/cdn/model/CreateIllegalUrlExportTaskRequest.h
+	include/alibabacloud/cdn/model/CreateIllegalUrlExportTaskResult.h
 	include/alibabacloud/cdn/model/CreateLiveStreamRecordIndexFilesRequest.h
 	include/alibabacloud/cdn/model/CreateLiveStreamRecordIndexFilesResult.h
 	include/alibabacloud/cdn/model/CreateRealTimeLogDeliveryRequest.h
@@ -211,6 +213,8 @@ set(cdn_public_header_model
 	include/alibabacloud/cdn/model/DescribeDomainsUsageByDayResult.h
 	include/alibabacloud/cdn/model/DescribeFCTriggerRequest.h
 	include/alibabacloud/cdn/model/DescribeFCTriggerResult.h
+	include/alibabacloud/cdn/model/DescribeIllegalUrlExportTaskRequest.h
+	include/alibabacloud/cdn/model/DescribeIllegalUrlExportTaskResult.h
 	include/alibabacloud/cdn/model/DescribeIpInfoRequest.h
 	include/alibabacloud/cdn/model/DescribeIpInfoResult.h
 	include/alibabacloud/cdn/model/DescribeL2VipsByDomainRequest.h
@@ -434,6 +438,8 @@ set(cdn_src
 	src/model/BatchUpdateCdnDomainResult.cc
 	src/model/CreateCdnCertificateSigningRequestRequest.cc
 	src/model/CreateCdnCertificateSigningRequestResult.cc
+	src/model/CreateIllegalUrlExportTaskRequest.cc
+	src/model/CreateIllegalUrlExportTaskResult.cc
 	src/model/CreateLiveStreamRecordIndexFilesRequest.cc
 	src/model/CreateLiveStreamRecordIndexFilesResult.cc
 	src/model/CreateRealTimeLogDeliveryRequest.cc
@@ -596,6 +602,8 @@ set(cdn_src
 	src/model/DescribeDomainsUsageByDayResult.cc
 	src/model/DescribeFCTriggerRequest.cc
 	src/model/DescribeFCTriggerResult.cc
+	src/model/DescribeIllegalUrlExportTaskRequest.cc
+	src/model/DescribeIllegalUrlExportTaskResult.cc
 	src/model/DescribeIpInfoRequest.cc
 	src/model/DescribeIpInfoResult.cc
 	src/model/DescribeL2VipsByDomainRequest.cc

cdn/include/alibabacloud/cdn/CdnClient.h

@@ -50,6 +50,8 @@
 #include "model/BatchUpdateCdnDomainResult.h"
 #include "model/CreateCdnCertificateSigningRequestRequest.h"
 #include "model/CreateCdnCertificateSigningRequestResult.h"
+#include "model/CreateIllegalUrlExportTaskRequest.h"
+#include "model/CreateIllegalUrlExportTaskResult.h"
 #include "model/CreateLiveStreamRecordIndexFilesRequest.h"
 #include "model/CreateLiveStreamRecordIndexFilesResult.h"
 #include "model/CreateRealTimeLogDeliveryRequest.h"
@@ -212,6 +214,8 @@
 #include "model/DescribeDomainsUsageByDayResult.h"
 #include "model/DescribeFCTriggerRequest.h"
 #include "model/DescribeFCTriggerResult.h"
+#include "model/DescribeIllegalUrlExportTaskRequest.h"
+#include "model/DescribeIllegalUrlExportTaskResult.h"
 #include "model/DescribeIpInfoRequest.h"
 #include "model/DescribeIpInfoResult.h"
 #include "model/DescribeL2VipsByDomainRequest.h"
@@ -455,6 +459,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateCdnCertificateSigningRequestResult> CreateCdnCertificateSigningRequestOutcome;
 			typedef std::future<CreateCdnCertificateSigningRequestOutcome> CreateCdnCertificateSigningRequestOutcomeCallable;
 			typedef std::function<void(const CdnClient*, const Model::CreateCdnCertificateSigningRequestRequest&, const CreateCdnCertificateSigningRequestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCdnCertificateSigningRequestAsyncHandler;
+			typedef Outcome<Error, Model::CreateIllegalUrlExportTaskResult> CreateIllegalUrlExportTaskOutcome;
+			typedef std::future<CreateIllegalUrlExportTaskOutcome> CreateIllegalUrlExportTaskOutcomeCallable;
+			typedef std::function<void(const CdnClient*, const Model::CreateIllegalUrlExportTaskRequest&, const CreateIllegalUrlExportTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateIllegalUrlExportTaskAsyncHandler;
 			typedef Outcome<Error, Model::CreateLiveStreamRecordIndexFilesResult> CreateLiveStreamRecordIndexFilesOutcome;
 			typedef std::future<CreateLiveStreamRecordIndexFilesOutcome> CreateLiveStreamRecordIndexFilesOutcomeCallable;
 			typedef std::function<void(const CdnClient*, const Model::CreateLiveStreamRecordIndexFilesRequest&, const CreateLiveStreamRecordIndexFilesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLiveStreamRecordIndexFilesAsyncHandler;
@@ -698,6 +705,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeFCTriggerResult> DescribeFCTriggerOutcome;
 			typedef std::future<DescribeFCTriggerOutcome> DescribeFCTriggerOutcomeCallable;
 			typedef std::function<void(const CdnClient*, const Model::DescribeFCTriggerRequest&, const DescribeFCTriggerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeFCTriggerAsyncHandler;
+			typedef Outcome<Error, Model::DescribeIllegalUrlExportTaskResult> DescribeIllegalUrlExportTaskOutcome;
+			typedef std::future<DescribeIllegalUrlExportTaskOutcome> DescribeIllegalUrlExportTaskOutcomeCallable;
+			typedef std::function<void(const CdnClient*, const Model::DescribeIllegalUrlExportTaskRequest&, const DescribeIllegalUrlExportTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeIllegalUrlExportTaskAsyncHandler;
 			typedef Outcome<Error, Model::DescribeIpInfoResult> DescribeIpInfoOutcome;
 			typedef std::future<DescribeIpInfoOutcome> DescribeIpInfoOutcomeCallable;
 			typedef std::function<void(const CdnClient*, const Model::DescribeIpInfoRequest&, const DescribeIpInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeIpInfoAsyncHandler;
@@ -1033,6 +1043,9 @@ namespace AlibabaCloud
 			CreateCdnCertificateSigningRequestOutcome createCdnCertificateSigningRequest(const Model::CreateCdnCertificateSigningRequestRequest &request)const;
 			void createCdnCertificateSigningRequestAsync(const Model::CreateCdnCertificateSigningRequestRequest& request, const CreateCdnCertificateSigningRequestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateCdnCertificateSigningRequestOutcomeCallable createCdnCertificateSigningRequestCallable(const Model::CreateCdnCertificateSigningRequestRequest& request) const;
+			CreateIllegalUrlExportTaskOutcome createIllegalUrlExportTask(const Model::CreateIllegalUrlExportTaskRequest &request)const;
+			void createIllegalUrlExportTaskAsync(const Model::CreateIllegalUrlExportTaskRequest& request, const CreateIllegalUrlExportTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateIllegalUrlExportTaskOutcomeCallable createIllegalUrlExportTaskCallable(const Model::CreateIllegalUrlExportTaskRequest& request) const;
 			CreateLiveStreamRecordIndexFilesOutcome createLiveStreamRecordIndexFiles(const Model::CreateLiveStreamRecordIndexFilesRequest &request)const;
 			void createLiveStreamRecordIndexFilesAsync(const Model::CreateLiveStreamRecordIndexFilesRequest& request, const CreateLiveStreamRecordIndexFilesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateLiveStreamRecordIndexFilesOutcomeCallable createLiveStreamRecordIndexFilesCallable(const Model::CreateLiveStreamRecordIndexFilesRequest& request) const;
@@ -1276,6 +1289,9 @@ namespace AlibabaCloud
 			DescribeFCTriggerOutcome describeFCTrigger(const Model::DescribeFCTriggerRequest &request)const;
 			void describeFCTriggerAsync(const Model::DescribeFCTriggerRequest& request, const DescribeFCTriggerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeFCTriggerOutcomeCallable describeFCTriggerCallable(const Model::DescribeFCTriggerRequest& request) const;
+			DescribeIllegalUrlExportTaskOutcome describeIllegalUrlExportTask(const Model::DescribeIllegalUrlExportTaskRequest &request)const;
+			void describeIllegalUrlExportTaskAsync(const Model::DescribeIllegalUrlExportTaskRequest& request, const DescribeIllegalUrlExportTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeIllegalUrlExportTaskOutcomeCallable describeIllegalUrlExportTaskCallable(const Model::DescribeIllegalUrlExportTaskRequest& request) const;
 			DescribeIpInfoOutcome describeIpInfo(const Model::DescribeIpInfoRequest &request)const;
 			void describeIpInfoAsync(const Model::DescribeIpInfoRequest& request, const DescribeIpInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeIpInfoOutcomeCallable describeIpInfoCallable(const Model::DescribeIpInfoRequest& request) const;

cdn/include/alibabacloud/cdn/model/BatchSetCdnDomainConfigRequest.h

@@ -39,19 +39,19 @@ namespace AlibabaCloud
 				void setFunctions(const std::string& functions);
 				std::string getDomainNames()const;
 				void setDomainNames(const std::string& domainNames);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
-				std::string getSecurityToken()const;
-				void setSecurityToken(const std::string& securityToken);
 
             private:
 				std::string functions_;
 				std::string domainNames_;
+				std::string securityToken_;
 				std::string ownerAccount_;
 				long ownerId_;
-				std::string securityToken_;
 
 			};
 		}

cdn/include/alibabacloud/cdn/model/CreateIllegalUrlExportTaskRequest.h

@@ -14,44 +14,41 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_IMM_MODEL_LISTTAGNAMESREQUEST_H_
-#define ALIBABACLOUD_IMM_MODEL_LISTTAGNAMESREQUEST_H_
+#ifndef ALIBABACLOUD_CDN_MODEL_CREATEILLEGALURLEXPORTTASKREQUEST_H_
+#define ALIBABACLOUD_CDN_MODEL_CREATEILLEGALURLEXPORTTASKREQUEST_H_
 
 #include <string>
 #include <vector>
 #include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/imm/ImmExport.h>
+#include <alibabacloud/cdn/CdnExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Imm
+	namespace Cdn
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_IMM_EXPORT ListTagNamesRequest : public RpcServiceRequest
+			class ALIBABACLOUD_CDN_EXPORT CreateIllegalUrlExportTaskRequest : public RpcServiceRequest
 			{
 
 			public:
-				ListTagNamesRequest();
-				~ListTagNamesRequest();
+				CreateIllegalUrlExportTaskRequest();
+				~CreateIllegalUrlExportTaskRequest();
 
-				std::string getProject()const;
-				void setProject(const std::string& project);
-				std::string getAccessKeyId()const;
-				void setAccessKeyId(const std::string& accessKeyId);
-				std::string getMarker()const;
-				void setMarker(const std::string& marker);
-				std::string getSetId()const;
-				void setSetId(const std::string& setId);
+				std::string getTaskName()const;
+				void setTaskName(const std::string& taskName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getTimePoint()const;
+				void setTimePoint(const std::string& timePoint);
 
             private:
-				std::string project_;
-				std::string accessKeyId_;
-				std::string marker_;
-				std::string setId_;
+				std::string taskName_;
+				long ownerId_;
+				std::string timePoint_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_IMM_MODEL_LISTTAGNAMESREQUEST_H_
+#endif // !ALIBABACLOUD_CDN_MODEL_CREATEILLEGALURLEXPORTTASKREQUEST_H_

cdn/include/alibabacloud/cdn/model/CreateIllegalUrlExportTaskResult.h

@@ -14,45 +14,38 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_IMM_MODEL_LISTTAGNAMESRESULT_H_
-#define ALIBABACLOUD_IMM_MODEL_LISTTAGNAMESRESULT_H_
+#ifndef ALIBABACLOUD_CDN_MODEL_CREATEILLEGALURLEXPORTTASKRESULT_H_
+#define ALIBABACLOUD_CDN_MODEL_CREATEILLEGALURLEXPORTTASKRESULT_H_
 
 #include <string>
 #include <vector>
 #include <utility>
 #include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/imm/ImmExport.h>
+#include <alibabacloud/cdn/CdnExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Imm
+	namespace Cdn
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_IMM_EXPORT ListTagNamesResult : public ServiceResult
+			class ALIBABACLOUD_CDN_EXPORT CreateIllegalUrlExportTaskResult : public ServiceResult
 			{
 			public:
-				struct TagsItem
-				{
-					std::string tagName;
-					int num;
-				};
 
 
-				ListTagNamesResult();
-				explicit ListTagNamesResult(const std::string &payload);
-				~ListTagNamesResult();
-				std::string getNextMarker()const;
-				std::vector<TagsItem> getTags()const;
+				CreateIllegalUrlExportTaskResult();
+				explicit CreateIllegalUrlExportTaskResult(const std::string &payload);
+				~CreateIllegalUrlExportTaskResult();
+				std::string getTaskId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string nextMarker_;
-				std::vector<TagsItem> tags_;
+				std::string taskId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_IMM_MODEL_LISTTAGNAMESRESULT_H_
+#endif // !ALIBABACLOUD_CDN_MODEL_CREATEILLEGALURLEXPORTTASKRESULT_H_

cdn/include/alibabacloud/cdn/model/DescribeIllegalUrlExportTaskRequest.h

@@ -14,44 +14,38 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_IMM_MODEL_COMPAREFACEREQUEST_H_
-#define ALIBABACLOUD_IMM_MODEL_COMPAREFACEREQUEST_H_
+#ifndef ALIBABACLOUD_CDN_MODEL_DESCRIBEILLEGALURLEXPORTTASKREQUEST_H_
+#define ALIBABACLOUD_CDN_MODEL_DESCRIBEILLEGALURLEXPORTTASKREQUEST_H_
 
 #include <string>
 #include <vector>
 #include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/imm/ImmExport.h>
+#include <alibabacloud/cdn/CdnExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Imm
+	namespace Cdn
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_IMM_EXPORT CompareFaceRequest : public RpcServiceRequest
+			class ALIBABACLOUD_CDN_EXPORT DescribeIllegalUrlExportTaskRequest : public RpcServiceRequest
 			{
 
 			public:
-				CompareFaceRequest();
-				~CompareFaceRequest();
+				DescribeIllegalUrlExportTaskRequest();
+				~DescribeIllegalUrlExportTaskRequest();
 
-				std::string getSrcUriB()const;
-				void setSrcUriB(const std::string& srcUriB);
-				std::string getSrcUriA()const;
-				void setSrcUriA(const std::string& srcUriA);
-				std::string getProject()const;
-				void setProject(const std::string& project);
-				std::string getAccessKeyId()const;
-				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getTaskId()const;
+				void setTaskId(const std::string& taskId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
 
             private:
-				std::string srcUriB_;
-				std::string srcUriA_;
-				std::string project_;
-				std::string accessKeyId_;
+				std::string taskId_;
+				long ownerId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_IMM_MODEL_COMPAREFACEREQUEST_H_
+#endif // !ALIBABACLOUD_CDN_MODEL_DESCRIBEILLEGALURLEXPORTTASKREQUEST_H_

cdn/include/alibabacloud/cdn/model/DescribeIllegalUrlExportTaskResult.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CDN_MODEL_DESCRIBEILLEGALURLEXPORTTASKRESULT_H_
+#define ALIBABACLOUD_CDN_MODEL_DESCRIBEILLEGALURLEXPORTTASKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cdn/CdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CDN_EXPORT DescribeIllegalUrlExportTaskResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeIllegalUrlExportTaskResult();
+				explicit DescribeIllegalUrlExportTaskResult(const std::string &payload);
+				~DescribeIllegalUrlExportTaskResult();
+				std::string getStatus()const;
+				std::string getDownloadUrl()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+				std::string downloadUrl_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CDN_MODEL_DESCRIBEILLEGALURLEXPORTTASKRESULT_H_

cdn/include/alibabacloud/cdn/model/RefreshObjectCachesRequest.h

@@ -37,18 +37,18 @@ namespace AlibabaCloud
 
 				std::string getObjectPath()const;
 				void setObjectPath(const std::string& objectPath);
-				long getOwnerId()const;
-				void setOwnerId(long ownerId);
 				std::string getSecurityToken()const;
 				void setSecurityToken(const std::string& securityToken);
 				std::string getObjectType()const;
 				void setObjectType(const std::string& objectType);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
 
             private:
 				std::string objectPath_;
-				long ownerId_;
 				std::string securityToken_;
 				std::string objectType_;
+				long ownerId_;
 
 			};
 		}

cdn/include/alibabacloud/cdn/model/SetCdnDomainCSRCertificateRequest.h

@@ -35,15 +35,15 @@ namespace AlibabaCloud
 				SetCdnDomainCSRCertificateRequest();
 				~SetCdnDomainCSRCertificateRequest();
 
-				std::string getCertificate()const;
-				void setCertificate(const std::string& certificate);
+				std::string getServerCertificate()const;
+				void setServerCertificate(const std::string& serverCertificate);
 				std::string getDomainName()const;
 				void setDomainName(const std::string& domainName);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 
             private:
-				std::string certificate_;
+				std::string serverCertificate_;
 				std::string domainName_;
 				long ownerId_;
 

cdn/src/CdnClient.cc

@@ -555,6 +555,42 @@ CdnClient::CreateCdnCertificateSigningRequestOutcomeCallable CdnClient::createCd
 	return task->get_future();
 }
 
+CdnClient::CreateIllegalUrlExportTaskOutcome CdnClient::createIllegalUrlExportTask(const CreateIllegalUrlExportTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateIllegalUrlExportTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateIllegalUrlExportTaskOutcome(CreateIllegalUrlExportTaskResult(outcome.result()));
+	else
+		return CreateIllegalUrlExportTaskOutcome(outcome.error());
+}
+
+void CdnClient::createIllegalUrlExportTaskAsync(const CreateIllegalUrlExportTaskRequest& request, const CreateIllegalUrlExportTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createIllegalUrlExportTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CdnClient::CreateIllegalUrlExportTaskOutcomeCallable CdnClient::createIllegalUrlExportTaskCallable(const CreateIllegalUrlExportTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateIllegalUrlExportTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->createIllegalUrlExportTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CdnClient::CreateLiveStreamRecordIndexFilesOutcome CdnClient::createLiveStreamRecordIndexFiles(const CreateLiveStreamRecordIndexFilesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3471,6 +3507,42 @@ CdnClient::DescribeFCTriggerOutcomeCallable CdnClient::describeFCTriggerCallable
 	return task->get_future();
 }
 
+CdnClient::DescribeIllegalUrlExportTaskOutcome CdnClient::describeIllegalUrlExportTask(const DescribeIllegalUrlExportTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeIllegalUrlExportTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeIllegalUrlExportTaskOutcome(DescribeIllegalUrlExportTaskResult(outcome.result()));
+	else
+		return DescribeIllegalUrlExportTaskOutcome(outcome.error());
+}
+
+void CdnClient::describeIllegalUrlExportTaskAsync(const DescribeIllegalUrlExportTaskRequest& request, const DescribeIllegalUrlExportTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeIllegalUrlExportTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CdnClient::DescribeIllegalUrlExportTaskOutcomeCallable CdnClient::describeIllegalUrlExportTaskCallable(const DescribeIllegalUrlExportTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeIllegalUrlExportTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->describeIllegalUrlExportTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CdnClient::DescribeIpInfoOutcome CdnClient::describeIpInfo(const DescribeIpInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

cdn/src/model/BatchSetCdnDomainConfigRequest.cc

@@ -49,6 +49,17 @@ void BatchSetCdnDomainConfigRequest::setDomainNames(const std::string& domainNam
 	setParameter("DomainNames", domainNames);
 }
 
+std::string BatchSetCdnDomainConfigRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void BatchSetCdnDomainConfigRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
 std::string BatchSetCdnDomainConfigRequest::getOwnerAccount()const
 {
 	return ownerAccount_;
@@ -71,14 +82,3 @@ void BatchSetCdnDomainConfigRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
-std::string BatchSetCdnDomainConfigRequest::getSecurityToken()const
-{
-	return securityToken_;
-}
-
-void BatchSetCdnDomainConfigRequest::setSecurityToken(const std::string& securityToken)
-{
-	securityToken_ = securityToken;
-	setParameter("SecurityToken", securityToken);
-}
-

cdn/src/model/CreateIllegalUrlExportTaskRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/cdn/model/CreateIllegalUrlExportTaskRequest.h>
+
+using AlibabaCloud::Cdn::Model::CreateIllegalUrlExportTaskRequest;
+
+CreateIllegalUrlExportTaskRequest::CreateIllegalUrlExportTaskRequest() :
+	RpcServiceRequest("cdn", "2018-05-10", "CreateIllegalUrlExportTask")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateIllegalUrlExportTaskRequest::~CreateIllegalUrlExportTaskRequest()
+{}
+
+std::string CreateIllegalUrlExportTaskRequest::getTaskName()const
+{
+	return taskName_;
+}
+
+void CreateIllegalUrlExportTaskRequest::setTaskName(const std::string& taskName)
+{
+	taskName_ = taskName;
+	setParameter("TaskName", taskName);
+}
+
+long CreateIllegalUrlExportTaskRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateIllegalUrlExportTaskRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateIllegalUrlExportTaskRequest::getTimePoint()const
+{
+	return timePoint_;
+}
+
+void CreateIllegalUrlExportTaskRequest::setTimePoint(const std::string& timePoint)
+{
+	timePoint_ = timePoint;
+	setParameter("TimePoint", timePoint);
+}
+

cdn/src/model/CreateIllegalUrlExportTaskResult.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/cdn/model/CreateIllegalUrlExportTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Cdn;
+using namespace AlibabaCloud::Cdn::Model;
+
+CreateIllegalUrlExportTaskResult::CreateIllegalUrlExportTaskResult() :
+	ServiceResult()
+{}
+
+CreateIllegalUrlExportTaskResult::CreateIllegalUrlExportTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateIllegalUrlExportTaskResult::~CreateIllegalUrlExportTaskResult()
+{}
+
+void CreateIllegalUrlExportTaskResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["TaskId"].isNull())
+		taskId_ = value["TaskId"].asString();
+
+}
+
+std::string CreateIllegalUrlExportTaskResult::getTaskId()const
+{
+	return taskId_;
+}
+

cdn/src/model/DescribeIllegalUrlExportTaskRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/cdn/model/DescribeIllegalUrlExportTaskRequest.h>
+
+using AlibabaCloud::Cdn::Model::DescribeIllegalUrlExportTaskRequest;
+
+DescribeIllegalUrlExportTaskRequest::DescribeIllegalUrlExportTaskRequest() :
+	RpcServiceRequest("cdn", "2018-05-10", "DescribeIllegalUrlExportTask")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeIllegalUrlExportTaskRequest::~DescribeIllegalUrlExportTaskRequest()
+{}
+
+std::string DescribeIllegalUrlExportTaskRequest::getTaskId()const
+{
+	return taskId_;
+}
+
+void DescribeIllegalUrlExportTaskRequest::setTaskId(const std::string& taskId)
+{
+	taskId_ = taskId;
+	setParameter("TaskId", taskId);
+}
+
+long DescribeIllegalUrlExportTaskRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeIllegalUrlExportTaskRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

cdn/src/model/DescribeIllegalUrlExportTaskResult.cc

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/cdn/model/DescribeIllegalUrlExportTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Cdn;
+using namespace AlibabaCloud::Cdn::Model;
+
+DescribeIllegalUrlExportTaskResult::DescribeIllegalUrlExportTaskResult() :
+	ServiceResult()
+{}
+
+DescribeIllegalUrlExportTaskResult::DescribeIllegalUrlExportTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeIllegalUrlExportTaskResult::~DescribeIllegalUrlExportTaskResult()
+{}
+
+void DescribeIllegalUrlExportTaskResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["DownloadUrl"].isNull())
+		downloadUrl_ = value["DownloadUrl"].asString();
+
+}
+
+std::string DescribeIllegalUrlExportTaskResult::getStatus()const
+{
+	return status_;
+}
+
+std::string DescribeIllegalUrlExportTaskResult::getDownloadUrl()const
+{
+	return downloadUrl_;
+}
+

cdn/src/model/RefreshObjectCachesRequest.cc

@@ -38,17 +38,6 @@ void RefreshObjectCachesRequest::setObjectPath(const std::string& objectPath)
 	setParameter("ObjectPath", objectPath);
 }
 
-long RefreshObjectCachesRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void RefreshObjectCachesRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
-}
-
 std::string RefreshObjectCachesRequest::getSecurityToken()const
 {
 	return securityToken_;
@@ -71,3 +60,14 @@ void RefreshObjectCachesRequest::setObjectType(const std::string& objectType)
 	setParameter("ObjectType", objectType);
 }
 
+long RefreshObjectCachesRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void RefreshObjectCachesRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

cdn/src/model/SetCdnDomainCSRCertificateRequest.cc

@@ -27,15 +27,15 @@ SetCdnDomainCSRCertificateRequest::SetCdnDomainCSRCertificateRequest() :
 SetCdnDomainCSRCertificateRequest::~SetCdnDomainCSRCertificateRequest()
 {}
 
-std::string SetCdnDomainCSRCertificateRequest::getCertificate()const
+std::string SetCdnDomainCSRCertificateRequest::getServerCertificate()const
 {
-	return certificate_;
+	return serverCertificate_;
 }
 
-void SetCdnDomainCSRCertificateRequest::setCertificate(const std::string& certificate)
+void SetCdnDomainCSRCertificateRequest::setServerCertificate(const std::string& serverCertificate)
 {
-	certificate_ = certificate;
-	setParameter("Certificate", certificate);
+	serverCertificate_ = serverCertificate;
+	setParameter("ServerCertificate", serverCertificate);
 }
 
 std::string SetCdnDomainCSRCertificateRequest::getDomainName()const

dbs/include/alibabacloud/dbs/model/ConfigureBackupPlanRequest.h

@@ -57,6 +57,8 @@ namespace AlibabaCloud
 				void setSourceEndpointIP(const std::string& sourceEndpointIP);
 				bool getEnableBackupLog()const;
 				void setEnableBackupLog(bool enableBackupLog);
+				std::string getBackupStorageType()const;
+				void setBackupStorageType(const std::string& backupStorageType);
 				int getDuplicationArchivePeriod()const;
 				void setDuplicationArchivePeriod(int duplicationArchivePeriod);
 				std::string getSourceEndpointPassword()const;
@@ -92,6 +94,7 @@ namespace AlibabaCloud
 				std::string backupStartTime_;
 				std::string sourceEndpointIP_;
 				bool enableBackupLog_;
+				std::string backupStorageType_;
 				int duplicationArchivePeriod_;
 				std::string sourceEndpointPassword_;
 				std::string backupObjects_;

dbs/src/DbsClient.cc

@@ -31,21 +31,21 @@ DbsClient::DbsClient(const Credentials &credentials, const ClientConfiguration &
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "cbs");
 }
 
 DbsClient::DbsClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "cbs");
 }
 
 DbsClient::DbsClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "cbs");
 }
 
 DbsClient::~DbsClient()

dbs/src/model/ConfigureBackupPlanRequest.cc

@@ -148,6 +148,17 @@ void ConfigureBackupPlanRequest::setEnableBackupLog(bool enableBackupLog)
 	setParameter("EnableBackupLog", enableBackupLog ? "true" : "false");
 }
 
+std::string ConfigureBackupPlanRequest::getBackupStorageType()const
+{
+	return backupStorageType_;
+}
+
+void ConfigureBackupPlanRequest::setBackupStorageType(const std::string& backupStorageType)
+{
+	backupStorageType_ = backupStorageType;
+	setParameter("BackupStorageType", backupStorageType);
+}
+
 int ConfigureBackupPlanRequest::getDuplicationArchivePeriod()const
 {
 	return duplicationArchivePeriod_;

ehpc/CMakeLists.txt

@@ -73,6 +73,8 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/DescribeClusterResult.h
 	include/alibabacloud/ehpc/model/DescribeContainerAppRequest.h
 	include/alibabacloud/ehpc/model/DescribeContainerAppResult.h
+	include/alibabacloud/ehpc/model/DescribeGWSClusterPolicyRequest.h
+	include/alibabacloud/ehpc/model/DescribeGWSClusterPolicyResult.h
 	include/alibabacloud/ehpc/model/DescribeGWSClustersRequest.h
 	include/alibabacloud/ehpc/model/DescribeGWSClustersResult.h
 	include/alibabacloud/ehpc/model/DescribeGWSImagesRequest.h
@@ -213,6 +215,8 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/RunCloudMetricProfilingResult.h
 	include/alibabacloud/ehpc/model/SetAutoScaleConfigRequest.h
 	include/alibabacloud/ehpc/model/SetAutoScaleConfigResult.h
+	include/alibabacloud/ehpc/model/SetGWSClusterPolicyRequest.h
+	include/alibabacloud/ehpc/model/SetGWSClusterPolicyResult.h
 	include/alibabacloud/ehpc/model/SetGWSInstanceNameRequest.h
 	include/alibabacloud/ehpc/model/SetGWSInstanceNameResult.h
 	include/alibabacloud/ehpc/model/SetGWSInstanceUserRequest.h
@@ -306,6 +310,8 @@ set(ehpc_src
 	src/model/DescribeClusterResult.cc
 	src/model/DescribeContainerAppRequest.cc
 	src/model/DescribeContainerAppResult.cc
+	src/model/DescribeGWSClusterPolicyRequest.cc
+	src/model/DescribeGWSClusterPolicyResult.cc
 	src/model/DescribeGWSClustersRequest.cc
 	src/model/DescribeGWSClustersResult.cc
 	src/model/DescribeGWSImagesRequest.cc
@@ -446,6 +452,8 @@ set(ehpc_src
 	src/model/RunCloudMetricProfilingResult.cc
 	src/model/SetAutoScaleConfigRequest.cc
 	src/model/SetAutoScaleConfigResult.cc
+	src/model/SetGWSClusterPolicyRequest.cc
+	src/model/SetGWSClusterPolicyResult.cc
 	src/model/SetGWSInstanceNameRequest.cc
 	src/model/SetGWSInstanceNameResult.cc
 	src/model/SetGWSInstanceUserRequest.cc

ehpc/ehpc.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace AlibabaCloud\ehpc;
+
+use AlibabaCloud\Client\Resolver\VersionResolver;
+
+/**
+ */
+class ehpc extends VersionResolver
+{
+}

ehpc/include/alibabacloud/ehpc/EHPCClient.h

@@ -74,6 +74,8 @@
 #include "model/DescribeClusterResult.h"
 #include "model/DescribeContainerAppRequest.h"
 #include "model/DescribeContainerAppResult.h"
+#include "model/DescribeGWSClusterPolicyRequest.h"
+#include "model/DescribeGWSClusterPolicyResult.h"
 #include "model/DescribeGWSClustersRequest.h"
 #include "model/DescribeGWSClustersResult.h"
 #include "model/DescribeGWSImagesRequest.h"
@@ -214,6 +216,8 @@
 #include "model/RunCloudMetricProfilingResult.h"
 #include "model/SetAutoScaleConfigRequest.h"
 #include "model/SetAutoScaleConfigResult.h"
+#include "model/SetGWSClusterPolicyRequest.h"
+#include "model/SetGWSClusterPolicyResult.h"
 #include "model/SetGWSInstanceNameRequest.h"
 #include "model/SetGWSInstanceNameResult.h"
 #include "model/SetGWSInstanceUserRequest.h"
@@ -339,6 +343,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeContainerAppResult> DescribeContainerAppOutcome;
 			typedef std::future<DescribeContainerAppOutcome> DescribeContainerAppOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::DescribeContainerAppRequest&, const DescribeContainerAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeContainerAppAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGWSClusterPolicyResult> DescribeGWSClusterPolicyOutcome;
+			typedef std::future<DescribeGWSClusterPolicyOutcome> DescribeGWSClusterPolicyOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeGWSClusterPolicyRequest&, const DescribeGWSClusterPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGWSClusterPolicyAsyncHandler;
 			typedef Outcome<Error, Model::DescribeGWSClustersResult> DescribeGWSClustersOutcome;
 			typedef std::future<DescribeGWSClustersOutcome> DescribeGWSClustersOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::DescribeGWSClustersRequest&, const DescribeGWSClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGWSClustersAsyncHandler;
@@ -549,6 +556,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::SetAutoScaleConfigResult> SetAutoScaleConfigOutcome;
 			typedef std::future<SetAutoScaleConfigOutcome> SetAutoScaleConfigOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::SetAutoScaleConfigRequest&, const SetAutoScaleConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetAutoScaleConfigAsyncHandler;
+			typedef Outcome<Error, Model::SetGWSClusterPolicyResult> SetGWSClusterPolicyOutcome;
+			typedef std::future<SetGWSClusterPolicyOutcome> SetGWSClusterPolicyOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::SetGWSClusterPolicyRequest&, const SetGWSClusterPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetGWSClusterPolicyAsyncHandler;
 			typedef Outcome<Error, Model::SetGWSInstanceNameResult> SetGWSInstanceNameOutcome;
 			typedef std::future<SetGWSInstanceNameOutcome> SetGWSInstanceNameOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::SetGWSInstanceNameRequest&, const SetGWSInstanceNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetGWSInstanceNameAsyncHandler;
@@ -689,6 +699,9 @@ namespace AlibabaCloud
 			DescribeContainerAppOutcome describeContainerApp(const Model::DescribeContainerAppRequest &request)const;
 			void describeContainerAppAsync(const Model::DescribeContainerAppRequest& request, const DescribeContainerAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeContainerAppOutcomeCallable describeContainerAppCallable(const Model::DescribeContainerAppRequest& request) const;
+			DescribeGWSClusterPolicyOutcome describeGWSClusterPolicy(const Model::DescribeGWSClusterPolicyRequest &request)const;
+			void describeGWSClusterPolicyAsync(const Model::DescribeGWSClusterPolicyRequest& request, const DescribeGWSClusterPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGWSClusterPolicyOutcomeCallable describeGWSClusterPolicyCallable(const Model::DescribeGWSClusterPolicyRequest& request) const;
 			DescribeGWSClustersOutcome describeGWSClusters(const Model::DescribeGWSClustersRequest &request)const;
 			void describeGWSClustersAsync(const Model::DescribeGWSClustersRequest& request, const DescribeGWSClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeGWSClustersOutcomeCallable describeGWSClustersCallable(const Model::DescribeGWSClustersRequest& request) const;
@@ -899,6 +912,9 @@ namespace AlibabaCloud
 			SetAutoScaleConfigOutcome setAutoScaleConfig(const Model::SetAutoScaleConfigRequest &request)const;
 			void setAutoScaleConfigAsync(const Model::SetAutoScaleConfigRequest& request, const SetAutoScaleConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetAutoScaleConfigOutcomeCallable setAutoScaleConfigCallable(const Model::SetAutoScaleConfigRequest& request) const;
+			SetGWSClusterPolicyOutcome setGWSClusterPolicy(const Model::SetGWSClusterPolicyRequest &request)const;
+			void setGWSClusterPolicyAsync(const Model::SetGWSClusterPolicyRequest& request, const SetGWSClusterPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetGWSClusterPolicyOutcomeCallable setGWSClusterPolicyCallable(const Model::SetGWSClusterPolicyRequest& request) const;
 			SetGWSInstanceNameOutcome setGWSInstanceName(const Model::SetGWSInstanceNameRequest &request)const;
 			void setGWSInstanceNameAsync(const Model::SetGWSInstanceNameRequest& request, const SetGWSInstanceNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetGWSInstanceNameOutcomeCallable setGWSInstanceNameCallable(const Model::SetGWSInstanceNameRequest& request) const;

ehpc/include/alibabacloud/ehpc/model/AddUsersRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT AddUsersRequest : public RpcServiceRequest
 			{
+			public:
 				struct User
 				{
 					std::string password;

ehpc/include/alibabacloud/ehpc/model/CreateClusterRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT CreateClusterRequest : public RpcServiceRequest
 			{
+			public:
 				struct AdditionalVolumes
 				{
 					std::string volumeType;

ehpc/include/alibabacloud/ehpc/model/CreateHybridClusterRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT CreateHybridClusterRequest : public RpcServiceRequest
 			{
+			public:
 				struct PostInstallScript
 				{
 					std::string args;

ehpc/include/alibabacloud/ehpc/model/DeleteContainerAppsRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT DeleteContainerAppsRequest : public RpcServiceRequest
 			{
+			public:
 				struct ContainerApp
 				{
 					std::string id;

ehpc/include/alibabacloud/ehpc/model/DeleteNodesRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT DeleteNodesRequest : public RpcServiceRequest
 			{
+			public:
 				struct Instance
 				{
 					std::string id;

ehpc/include/alibabacloud/ehpc/model/DeleteUsersRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT DeleteUsersRequest : public RpcServiceRequest
 			{
+			public:
 				struct User
 				{
 					std::string name;

ehpc/include/alibabacloud/ehpc/model/DescribeClusterResult.h

@@ -87,6 +87,7 @@ namespace AlibabaCloud
 					std::string schedulerType;
 					std::string accountType;
 					std::string volumeMountpoint;
+					std::string baseOsTag;
 					std::string vpcId;
 					EcsInfo ecsInfo;
 					bool haEnable;

ehpc/include/alibabacloud/ehpc/model/DescribeGWSClusterPolicyRequest.h

@@ -14,41 +14,38 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_IMM_MODEL_DETECTCLOTHESREQUEST_H_
-#define ALIBABACLOUD_IMM_MODEL_DETECTCLOTHESREQUEST_H_
+#ifndef ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSCLUSTERPOLICYREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSCLUSTERPOLICYREQUEST_H_
 
 #include <string>
 #include <vector>
 #include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/imm/ImmExport.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Imm
+	namespace EHPC
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_IMM_EXPORT DetectClothesRequest : public RpcServiceRequest
+			class ALIBABACLOUD_EHPC_EXPORT DescribeGWSClusterPolicyRequest : public RpcServiceRequest
 			{
 
 			public:
-				DetectClothesRequest();
-				~DetectClothesRequest();
+				DescribeGWSClusterPolicyRequest();
+				~DescribeGWSClusterPolicyRequest();
 
-				std::string getProject()const;
-				void setProject(const std::string& project);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
-				std::string getSrcUris()const;
-				void setSrcUris(const std::string& srcUris);
 
             private:
-				std::string project_;
+				std::string clusterId_;
 				std::string accessKeyId_;
-				std::string srcUris_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_IMM_MODEL_DETECTCLOTHESREQUEST_H_
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSCLUSTERPOLICYREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DescribeGWSClusterPolicyResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSCLUSTERPOLICYRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSCLUSTERPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT DescribeGWSClusterPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeGWSClusterPolicyResult();
+				explicit DescribeGWSClusterPolicyResult(const std::string &payload);
+				~DescribeGWSClusterPolicyResult();
+				std::string getLocalDrive()const;
+				std::string getUsbRedirect()const;
+				std::string getClipboard()const;
+				std::string getWatermark()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string localDrive_;
+				std::string usbRedirect_;
+				std::string clipboard_;
+				std::string watermark_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSCLUSTERPOLICYRESULT_H_

ehpc/include/alibabacloud/ehpc/model/DescribePriceRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT DescribePriceRequest : public RpcServiceRequest
 			{
+			public:
 				struct Commodities
 				{
 					int amount;

ehpc/include/alibabacloud/ehpc/model/GetAccountingReportRequest.h

@@ -41,20 +41,32 @@ namespace AlibabaCloud
 				void setEndTime(int endTime);
 				std::string getFilterValue()const;
 				void setFilterValue(const std::string& filterValue);
+				std::string getDim()const;
+				void setDim(const std::string& dim);
 				std::string getClusterId()const;
 				void setClusterId(const std::string& clusterId);
 				int getStartTime()const;
 				void setStartTime(int startTime);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getJobId()const;
+				void setJobId(const std::string& jobId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
 
             private:
 				std::string reportType_;
 				int endTime_;
 				std::string filterValue_;
+				std::string dim_;
 				std::string clusterId_;
 				int startTime_;
+				int pageNumber_;
 				std::string accessKeyId_;
+				std::string jobId_;
+				int pageSize_;
 
 			};
 		}

ehpc/include/alibabacloud/ehpc/model/GetAccountingReportResult.h

@@ -38,13 +38,21 @@ namespace AlibabaCloud
 				explicit GetAccountingReportResult(const std::string &payload);
 				~GetAccountingReportResult();
 				std::string getMetrics()const;
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
 				std::vector<std::string> getData()const;
+				int getTotalCoreTime()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
 				std::string metrics_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
 				std::vector<std::string> data_;
+				int totalCoreTime_;
 
 			};
 		}

ehpc/include/alibabacloud/ehpc/model/GetAutoScaleConfigResult.h

@@ -43,6 +43,7 @@ namespace AlibabaCloud
 						std::string instanceType;
 						std::string spotStrategy;
 					};
+					int maxNodesInQueue;
 					std::string resourceGroupId;
 					bool enableAutoGrow;
 					float spotPriceLimit;
@@ -68,6 +69,7 @@ namespace AlibabaCloud
 				int getGrowIntervalInMinutes()const;
 				std::string getUid()const;
 				int getGrowTimeoutInMinutes()const;
+				std::string getImageId()const;
 				int getShrinkIntervalInMinutes()const;
 				float getSpotPriceLimit()const;
 				std::vector<QueueInfo> getQueues()const;
@@ -88,6 +90,7 @@ namespace AlibabaCloud
 				int growIntervalInMinutes_;
 				std::string uid_;
 				int growTimeoutInMinutes_;
+				std::string imageId_;
 				int shrinkIntervalInMinutes_;
 				float spotPriceLimit_;
 				std::vector<QueueInfo> queues_;

ehpc/include/alibabacloud/ehpc/model/InvokeShellCommandRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT InvokeShellCommandRequest : public RpcServiceRequest
 			{
+			public:
 				struct Instance
 				{
 					std::string id;

ehpc/include/alibabacloud/ehpc/model/ListClustersResult.h

@@ -81,6 +81,7 @@ namespace AlibabaCloud
 					std::string schedulerType;
 					std::string accountType;
 					std::string ehpcVersion;
+					std::string baseOsTag;
 					UsedResources usedResources;
 					std::string vpcId;
 					Managers managers;

ehpc/include/alibabacloud/ehpc/model/ListCustomImagesRequest.h

@@ -41,11 +41,14 @@ namespace AlibabaCloud
 				void setImageOwnerAlias(const std::string& imageOwnerAlias);
 				std::string getBaseOsTag()const;
 				void setBaseOsTag(const std::string& baseOsTag);
+				std::string getInstanceType()const;
+				void setInstanceType(const std::string& instanceType);
 
             private:
 				std::string accessKeyId_;
 				std::string imageOwnerAlias_;
 				std::string baseOsTag_;
+				std::string instanceType_;
 
 			};
 		}

ehpc/include/alibabacloud/ehpc/model/ListCustomImagesResult.h

@@ -41,18 +41,27 @@ namespace AlibabaCloud
 						std::string version;
 						std::string osTag;
 					};
+					struct OsTag
+					{
+						std::string platform;
+						std::string architecture;
+						std::string version;
+						std::string osTag;
+						std::string baseOsTag;
+					};
 					std::string imageOwnerAlias;
 					std::string status;
-					std::string uid;
-					std::string imageName;
 					std::string description;
-					std::string postInstallScript;
 					std::string productCode;
 					std::string skuCode;
 					std::string pricingCycle;
 					int size;
-					std::string imageId;
 					BaseOsTag baseOsTag;
+					std::string uid;
+					std::string imageName;
+					std::string postInstallScript;
+					OsTag osTag;
+					std::string imageId;
 				};
 
 

ehpc/include/alibabacloud/ehpc/model/ListImagesRequest.h

@@ -37,9 +37,15 @@ namespace AlibabaCloud
 
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getBaseOsTag()const;
+				void setBaseOsTag(const std::string& baseOsTag);
+				std::string getInstanceType()const;
+				void setInstanceType(const std::string& instanceType);
 
             private:
 				std::string accessKeyId_;
+				std::string baseOsTag_;
+				std::string instanceType_;
 
 			};
 		}

ehpc/include/alibabacloud/ehpc/model/ListImagesResult.h

@@ -38,6 +38,8 @@ namespace AlibabaCloud
 					std::string architecture;
 					std::string version;
 					std::string osTag;
+					std::string imageId;
+					std::string baseOsTag;
 				};
 
 

ehpc/include/alibabacloud/ehpc/model/ListInvocationResultsRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT ListInvocationResultsRequest : public RpcServiceRequest
 			{
+			public:
 				struct Instance
 				{
 					std::string id;

ehpc/include/alibabacloud/ehpc/model/ListNodesByQueueResult.h

@@ -60,6 +60,7 @@ namespace AlibabaCloud
 					TotalResources totalResources;
 					std::string expiredTime;
 					std::string imageId;
+					bool htEnabled;
 					std::string id;
 					std::string regionId;
 					std::string lockReason;

ehpc/include/alibabacloud/ehpc/model/ListNodesNoPagingResult.h

@@ -57,6 +57,7 @@ namespace AlibabaCloud
 					TotalResources totalResources;
 					std::string expiredTime;
 					std::string imageId;
+					bool htEnabled;
 					std::string id;
 					std::string regionId;
 					std::string lockReason;

ehpc/include/alibabacloud/ehpc/model/ListNodesResult.h

@@ -62,6 +62,7 @@ namespace AlibabaCloud
 					std::string expiredTime;
 					std::string imageId;
 					std::string ipAddress;
+					bool htEnabled;
 					std::string id;
 					std::string regionId;
 					std::string lockReason;

ehpc/include/alibabacloud/ehpc/model/ListSoftwaresRequest.h

@@ -35,12 +35,15 @@ namespace AlibabaCloud
 				ListSoftwaresRequest();
 				~ListSoftwaresRequest();
 
+				std::string getOsTag()const;
+				void setOsTag(const std::string& osTag);
 				std::string getEhpcVersion()const;
 				void setEhpcVersion(const std::string& ehpcVersion);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
 
             private:
+				std::string osTag_;
 				std::string ehpcVersion_;
 				std::string accessKeyId_;
 

ehpc/include/alibabacloud/ehpc/model/ModifyImageGatewayConfigRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT ModifyImageGatewayConfigRequest : public RpcServiceRequest
 			{
+			public:
 				struct Repo
 				{
 					std::string auth;

ehpc/include/alibabacloud/ehpc/model/ModifyUserGroupsRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT ModifyUserGroupsRequest : public RpcServiceRequest
 			{
+			public:
 				struct User
 				{
 					std::string name;

ehpc/include/alibabacloud/ehpc/model/ModifyUserPasswordsRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT ModifyUserPasswordsRequest : public RpcServiceRequest
 			{
+			public:
 				struct User
 				{
 					std::string password;

ehpc/include/alibabacloud/ehpc/model/ResetNodesRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT ResetNodesRequest : public RpcServiceRequest
 			{
+			public:
 				struct Instance
 				{
 					std::string id;

ehpc/include/alibabacloud/ehpc/model/SetAutoScaleConfigRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT SetAutoScaleConfigRequest : public RpcServiceRequest
 			{
+			public:
 				struct Queues
 				{
 					std::string spotStrategy;
@@ -44,6 +45,7 @@ namespace AlibabaCloud
 						float spotPriceLimit;
 					};
 					std::vector<InstanceTypes> instanceTypes;
+					int maxNodesInQueue;
 					std::string instanceType;
 					bool enableAutoGrow;
 					float spotPriceLimit;
@@ -54,6 +56,8 @@ namespace AlibabaCloud
 				SetAutoScaleConfigRequest();
 				~SetAutoScaleConfigRequest();
 
+				std::string getImageId()const;
+				void setImageId(const std::string& imageId);
 				float getSpotPriceLimit()const;
 				void setSpotPriceLimit(float spotPriceLimit);
 				std::string getAccessKeyId()const;
@@ -86,6 +90,7 @@ namespace AlibabaCloud
 				void setGrowRatio(int growRatio);
 
             private:
+				std::string imageId_;
 				float spotPriceLimit_;
 				std::string accessKeyId_;
 				std::string excludeNodes_;

ehpc/include/alibabacloud/ehpc/model/SetGWSClusterPolicyRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_SETGWSCLUSTERPOLICYREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_SETGWSCLUSTERPOLICYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT SetGWSClusterPolicyRequest : public RpcServiceRequest
+			{
+
+			public:
+				SetGWSClusterPolicyRequest();
+				~SetGWSClusterPolicyRequest();
+
+				std::string getWatermark()const;
+				void setWatermark(const std::string& watermark);
+				std::string getLocalDrive()const;
+				void setLocalDrive(const std::string& localDrive);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getClipboard()const;
+				void setClipboard(const std::string& clipboard);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getUsbRedirect()const;
+				void setUsbRedirect(const std::string& usbRedirect);
+
+            private:
+				std::string watermark_;
+				std::string localDrive_;
+				std::string clusterId_;
+				std::string clipboard_;
+				std::string accessKeyId_;
+				std::string usbRedirect_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_SETGWSCLUSTERPOLICYREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/SetGWSClusterPolicyResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_SETGWSCLUSTERPOLICYRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_SETGWSCLUSTERPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT SetGWSClusterPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				SetGWSClusterPolicyResult();
+				explicit SetGWSClusterPolicyResult(const std::string &payload);
+				~SetGWSClusterPolicyResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_SETGWSCLUSTERPOLICYRESULT_H_

ehpc/include/alibabacloud/ehpc/model/SetQueueRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT SetQueueRequest : public RpcServiceRequest
 			{
+			public:
 				struct Node
 				{
 					std::string name;

ehpc/include/alibabacloud/ehpc/model/StartNodesRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT StartNodesRequest : public RpcServiceRequest
 			{
+			public:
 				struct Instance
 				{
 					std::string id;

ehpc/include/alibabacloud/ehpc/model/StopNodesRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT StopNodesRequest : public RpcServiceRequest
 			{
+			public:
 				struct Instance
 				{
 					std::string id;

ehpc/include/alibabacloud/ehpc/model/UpdateClusterVolumesRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT UpdateClusterVolumesRequest : public RpcServiceRequest
 			{
+			public:
 				struct AdditionalVolumes
 				{
 					std::string volumeType;

ehpc/src/EHPCClient.cc

@@ -987,6 +987,42 @@ EHPCClient::DescribeContainerAppOutcomeCallable EHPCClient::describeContainerApp
 	return task->get_future();
 }
 
+EHPCClient::DescribeGWSClusterPolicyOutcome EHPCClient::describeGWSClusterPolicy(const DescribeGWSClusterPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeGWSClusterPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeGWSClusterPolicyOutcome(DescribeGWSClusterPolicyResult(outcome.result()));
+	else
+		return DescribeGWSClusterPolicyOutcome(outcome.error());
+}
+
+void EHPCClient::describeGWSClusterPolicyAsync(const DescribeGWSClusterPolicyRequest& request, const DescribeGWSClusterPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeGWSClusterPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::DescribeGWSClusterPolicyOutcomeCallable EHPCClient::describeGWSClusterPolicyCallable(const DescribeGWSClusterPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeGWSClusterPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->describeGWSClusterPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::DescribeGWSClustersOutcome EHPCClient::describeGWSClusters(const DescribeGWSClustersRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3507,6 +3543,42 @@ EHPCClient::SetAutoScaleConfigOutcomeCallable EHPCClient::setAutoScaleConfigCall
 	return task->get_future();
 }
 
+EHPCClient::SetGWSClusterPolicyOutcome EHPCClient::setGWSClusterPolicy(const SetGWSClusterPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetGWSClusterPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetGWSClusterPolicyOutcome(SetGWSClusterPolicyResult(outcome.result()));
+	else
+		return SetGWSClusterPolicyOutcome(outcome.error());
+}
+
+void EHPCClient::setGWSClusterPolicyAsync(const SetGWSClusterPolicyRequest& request, const SetGWSClusterPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setGWSClusterPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::SetGWSClusterPolicyOutcomeCallable EHPCClient::setGWSClusterPolicyCallable(const SetGWSClusterPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetGWSClusterPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->setGWSClusterPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::SetGWSInstanceNameOutcome EHPCClient::setGWSInstanceName(const SetGWSInstanceNameRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ehpc/src/model/AddContainerAppRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::AddContainerAppRequest;
 AddContainerAppRequest::AddContainerAppRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "AddContainerApp")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 AddContainerAppRequest::~AddContainerAppRequest()
@@ -35,7 +35,7 @@ std::string AddContainerAppRequest::getDescription()const
 void AddContainerAppRequest::setDescription(const std::string& description)
 {
 	description_ = description;
-	setCoreParameter("Description", description);
+	setParameter("Description", description);
 }
 
 std::string AddContainerAppRequest::getRepository()const
@@ -46,7 +46,7 @@ std::string AddContainerAppRequest::getRepository()const
 void AddContainerAppRequest::setRepository(const std::string& repository)
 {
 	repository_ = repository;
-	setCoreParameter("Repository", repository);
+	setParameter("Repository", repository);
 }
 
 std::string AddContainerAppRequest::getAccessKeyId()const
@@ -57,7 +57,7 @@ std::string AddContainerAppRequest::getAccessKeyId()const
 void AddContainerAppRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string AddContainerAppRequest::getContainerType()const
@@ -68,7 +68,7 @@ std::string AddContainerAppRequest::getContainerType()const
 void AddContainerAppRequest::setContainerType(const std::string& containerType)
 {
 	containerType_ = containerType;
-	setCoreParameter("ContainerType", containerType);
+	setParameter("ContainerType", containerType);
 }
 
 std::string AddContainerAppRequest::getName()const
@@ -79,7 +79,7 @@ std::string AddContainerAppRequest::getName()const
 void AddContainerAppRequest::setName(const std::string& name)
 {
 	name_ = name;
-	setCoreParameter("Name", name);
+	setParameter("Name", name);
 }
 
 std::string AddContainerAppRequest::getImageTag()const
@@ -90,6 +90,6 @@ std::string AddContainerAppRequest::getImageTag()const
 void AddContainerAppRequest::setImageTag(const std::string& imageTag)
 {
 	imageTag_ = imageTag;
-	setCoreParameter("ImageTag", imageTag);
+	setParameter("ImageTag", imageTag);
 }
 

ehpc/src/model/AddLocalNodesRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::AddLocalNodesRequest;
 AddLocalNodesRequest::AddLocalNodesRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "AddLocalNodes")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 AddLocalNodesRequest::~AddLocalNodesRequest()
@@ -35,7 +35,7 @@ std::string AddLocalNodesRequest::getClusterId()const
 void AddLocalNodesRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string AddLocalNodesRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string AddLocalNodesRequest::getAccessKeyId()const
 void AddLocalNodesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string AddLocalNodesRequest::getNodes()const
@@ -57,6 +57,6 @@ std::string AddLocalNodesRequest::getNodes()const
 void AddLocalNodesRequest::setNodes(const std::string& nodes)
 {
 	nodes_ = nodes;
-	setCoreParameter("Nodes", nodes);
+	setParameter("Nodes", nodes);
 }
 

ehpc/src/model/AddNodesRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::AddNodesRequest;
 AddNodesRequest::AddNodesRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "AddNodes")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 AddNodesRequest::~AddNodesRequest()
@@ -35,7 +35,7 @@ std::string AddNodesRequest::getImageId()const
 void AddNodesRequest::setImageId(const std::string& imageId)
 {
 	imageId_ = imageId;
-	setCoreParameter("ImageId", imageId);
+	setParameter("ImageId", imageId);
 }
 
 std::string AddNodesRequest::getJobQueue()const
@@ -46,7 +46,7 @@ std::string AddNodesRequest::getJobQueue()const
 void AddNodesRequest::setJobQueue(const std::string& jobQueue)
 {
 	jobQueue_ = jobQueue;
-	setCoreParameter("JobQueue", jobQueue);
+	setParameter("JobQueue", jobQueue);
 }
 
 std::string AddNodesRequest::getAccessKeyId()const
@@ -57,7 +57,7 @@ std::string AddNodesRequest::getAccessKeyId()const
 void AddNodesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string AddNodesRequest::getImageOwnerAlias()const
@@ -68,7 +68,7 @@ std::string AddNodesRequest::getImageOwnerAlias()const
 void AddNodesRequest::setImageOwnerAlias(const std::string& imageOwnerAlias)
 {
 	imageOwnerAlias_ = imageOwnerAlias;
-	setCoreParameter("ImageOwnerAlias", imageOwnerAlias);
+	setParameter("ImageOwnerAlias", imageOwnerAlias);
 }
 
 std::string AddNodesRequest::getSystemDiskType()const
@@ -79,7 +79,7 @@ std::string AddNodesRequest::getSystemDiskType()const
 void AddNodesRequest::setSystemDiskType(const std::string& systemDiskType)
 {
 	systemDiskType_ = systemDiskType;
-	setCoreParameter("SystemDiskType", systemDiskType);
+	setParameter("SystemDiskType", systemDiskType);
 }
 
 int AddNodesRequest::getSystemDiskSize()const
@@ -90,7 +90,7 @@ int AddNodesRequest::getSystemDiskSize()const
 void AddNodesRequest::setSystemDiskSize(int systemDiskSize)
 {
 	systemDiskSize_ = systemDiskSize;
-	setCoreParameter("SystemDiskSize", std::to_string(systemDiskSize));
+	setParameter("SystemDiskSize", std::to_string(systemDiskSize));
 }
 
 std::string AddNodesRequest::getInstanceType()const
@@ -101,7 +101,7 @@ std::string AddNodesRequest::getInstanceType()const
 void AddNodesRequest::setInstanceType(const std::string& instanceType)
 {
 	instanceType_ = instanceType;
-	setCoreParameter("InstanceType", instanceType);
+	setParameter("InstanceType", instanceType);
 }
 
 std::string AddNodesRequest::getHostNamePrefix()const
@@ -112,7 +112,7 @@ std::string AddNodesRequest::getHostNamePrefix()const
 void AddNodesRequest::setHostNamePrefix(const std::string& hostNamePrefix)
 {
 	hostNamePrefix_ = hostNamePrefix;
-	setCoreParameter("HostNamePrefix", hostNamePrefix);
+	setParameter("HostNamePrefix", hostNamePrefix);
 }
 
 std::string AddNodesRequest::getComputeSpotPriceLimit()const
@@ -123,7 +123,7 @@ std::string AddNodesRequest::getComputeSpotPriceLimit()const
 void AddNodesRequest::setComputeSpotPriceLimit(const std::string& computeSpotPriceLimit)
 {
 	computeSpotPriceLimit_ = computeSpotPriceLimit;
-	setCoreParameter("ComputeSpotPriceLimit", computeSpotPriceLimit);
+	setParameter("ComputeSpotPriceLimit", computeSpotPriceLimit);
 }
 
 int AddNodesRequest::getAutoRenewPeriod()const
@@ -134,7 +134,7 @@ int AddNodesRequest::getAutoRenewPeriod()const
 void AddNodesRequest::setAutoRenewPeriod(int autoRenewPeriod)
 {
 	autoRenewPeriod_ = autoRenewPeriod;
-	setCoreParameter("AutoRenewPeriod", std::to_string(autoRenewPeriod));
+	setParameter("AutoRenewPeriod", std::to_string(autoRenewPeriod));
 }
 
 int AddNodesRequest::getPeriod()const
@@ -145,7 +145,7 @@ int AddNodesRequest::getPeriod()const
 void AddNodesRequest::setPeriod(int period)
 {
 	period_ = period;
-	setCoreParameter("Period", std::to_string(period));
+	setParameter("Period", std::to_string(period));
 }
 
 int AddNodesRequest::getCount()const
@@ -156,7 +156,7 @@ int AddNodesRequest::getCount()const
 void AddNodesRequest::setCount(int count)
 {
 	count_ = count;
-	setCoreParameter("Count", std::to_string(count));
+	setParameter("Count", std::to_string(count));
 }
 
 std::string AddNodesRequest::getClusterId()const
@@ -167,7 +167,7 @@ std::string AddNodesRequest::getClusterId()const
 void AddNodesRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string AddNodesRequest::getComputeSpotStrategy()const
@@ -178,7 +178,7 @@ std::string AddNodesRequest::getComputeSpotStrategy()const
 void AddNodesRequest::setComputeSpotStrategy(const std::string& computeSpotStrategy)
 {
 	computeSpotStrategy_ = computeSpotStrategy;
-	setCoreParameter("ComputeSpotStrategy", computeSpotStrategy);
+	setParameter("ComputeSpotStrategy", computeSpotStrategy);
 }
 
 std::string AddNodesRequest::getHostNameSuffix()const
@@ -189,7 +189,7 @@ std::string AddNodesRequest::getHostNameSuffix()const
 void AddNodesRequest::setHostNameSuffix(const std::string& hostNameSuffix)
 {
 	hostNameSuffix_ = hostNameSuffix;
-	setCoreParameter("HostNameSuffix", hostNameSuffix);
+	setParameter("HostNameSuffix", hostNameSuffix);
 }
 
 std::string AddNodesRequest::getVSwitchId()const
@@ -200,7 +200,7 @@ std::string AddNodesRequest::getVSwitchId()const
 void AddNodesRequest::setVSwitchId(const std::string& vSwitchId)
 {
 	vSwitchId_ = vSwitchId;
-	setCoreParameter("VSwitchId", vSwitchId);
+	setParameter("VSwitchId", vSwitchId);
 }
 
 std::string AddNodesRequest::getPeriodUnit()const
@@ -211,7 +211,7 @@ std::string AddNodesRequest::getPeriodUnit()const
 void AddNodesRequest::setPeriodUnit(const std::string& periodUnit)
 {
 	periodUnit_ = periodUnit;
-	setCoreParameter("PeriodUnit", periodUnit);
+	setParameter("PeriodUnit", periodUnit);
 }
 
 bool AddNodesRequest::getComputeEnableHt()const
@@ -222,7 +222,7 @@ bool AddNodesRequest::getComputeEnableHt()const
 void AddNodesRequest::setComputeEnableHt(bool computeEnableHt)
 {
 	computeEnableHt_ = computeEnableHt;
-	setCoreParameter("ComputeEnableHt", computeEnableHt ? "true" : "false");
+	setParameter("ComputeEnableHt", computeEnableHt ? "true" : "false");
 }
 
 std::string AddNodesRequest::getAutoRenew()const
@@ -233,7 +233,7 @@ std::string AddNodesRequest::getAutoRenew()const
 void AddNodesRequest::setAutoRenew(const std::string& autoRenew)
 {
 	autoRenew_ = autoRenew;
-	setCoreParameter("AutoRenew", autoRenew);
+	setParameter("AutoRenew", autoRenew);
 }
 
 std::string AddNodesRequest::getEcsChargeType()const
@@ -244,7 +244,7 @@ std::string AddNodesRequest::getEcsChargeType()const
 void AddNodesRequest::setEcsChargeType(const std::string& ecsChargeType)
 {
 	ecsChargeType_ = ecsChargeType;
-	setCoreParameter("EcsChargeType", ecsChargeType);
+	setParameter("EcsChargeType", ecsChargeType);
 }
 
 std::string AddNodesRequest::getCreateMode()const
@@ -255,7 +255,7 @@ std::string AddNodesRequest::getCreateMode()const
 void AddNodesRequest::setCreateMode(const std::string& createMode)
 {
 	createMode_ = createMode;
-	setCoreParameter("CreateMode", createMode);
+	setParameter("CreateMode", createMode);
 }
 
 std::string AddNodesRequest::getZoneId()const
@@ -266,6 +266,6 @@ std::string AddNodesRequest::getZoneId()const
 void AddNodesRequest::setZoneId(const std::string& zoneId)
 {
 	zoneId_ = zoneId;
-	setCoreParameter("ZoneId", zoneId);
+	setParameter("ZoneId", zoneId);
 }
 

ehpc/src/model/AddQueueRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::AddQueueRequest;
 AddQueueRequest::AddQueueRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "AddQueue")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 AddQueueRequest::~AddQueueRequest()
@@ -35,7 +35,7 @@ std::string AddQueueRequest::getQueueName()const
 void AddQueueRequest::setQueueName(const std::string& queueName)
 {
 	queueName_ = queueName;
-	setCoreParameter("QueueName", queueName);
+	setParameter("QueueName", queueName);
 }
 
 std::string AddQueueRequest::getClusterId()const
@@ -46,7 +46,7 @@ std::string AddQueueRequest::getClusterId()const
 void AddQueueRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string AddQueueRequest::getAccessKeyId()const
@@ -57,6 +57,6 @@ std::string AddQueueRequest::getAccessKeyId()const
 void AddQueueRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/AddUsersRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::AddUsersRequest;
 AddUsersRequest::AddUsersRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "AddUsers")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 AddUsersRequest::~AddUsersRequest()
@@ -35,7 +35,7 @@ std::string AddUsersRequest::getClusterId()const
 void AddUsersRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string AddUsersRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string AddUsersRequest::getAccessKeyId()const
 void AddUsersRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::vector<AddUsersRequest::User> AddUsersRequest::getUser()const
@@ -59,10 +59,10 @@ void AddUsersRequest::setUser(const std::vector<User>& user)
 	user_ = user;
 	for(int dep1 = 0; dep1!= user.size(); dep1++) {
 		auto userObj = user.at(dep1);
-		std::string userObjStr = "User." + std::to_string(dep1);
-		setCoreParameter(userObjStr + ".Password", userObj.password);
-		setCoreParameter(userObjStr + ".Name", userObj.name);
-		setCoreParameter(userObjStr + ".Group", userObj.group);
+		std::string userObjStr = "User." + std::to_string(dep1 + 1);
+		setParameter(userObjStr + ".Password", userObj.password);
+		setParameter(userObjStr + ".Name", userObj.name);
+		setParameter(userObjStr + ".Group", userObj.group);
 	}
 }
 

ehpc/src/model/BindAccountToClusterUserRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::BindAccountToClusterUserRequest;
 BindAccountToClusterUserRequest::BindAccountToClusterUserRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "BindAccountToClusterUser")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 BindAccountToClusterUserRequest::~BindAccountToClusterUserRequest()
@@ -35,7 +35,7 @@ std::string BindAccountToClusterUserRequest::getUserPwd()const
 void BindAccountToClusterUserRequest::setUserPwd(const std::string& userPwd)
 {
 	userPwd_ = userPwd;
-	setCoreParameter("UserPwd", userPwd);
+	setParameter("UserPwd", userPwd);
 }
 
 std::string BindAccountToClusterUserRequest::getClusterId()const
@@ -46,7 +46,7 @@ std::string BindAccountToClusterUserRequest::getClusterId()const
 void BindAccountToClusterUserRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string BindAccountToClusterUserRequest::getAccessKeyId()const
@@ -57,7 +57,7 @@ std::string BindAccountToClusterUserRequest::getAccessKeyId()const
 void BindAccountToClusterUserRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string BindAccountToClusterUserRequest::getAccountName()const
@@ -68,7 +68,7 @@ std::string BindAccountToClusterUserRequest::getAccountName()const
 void BindAccountToClusterUserRequest::setAccountName(const std::string& accountName)
 {
 	accountName_ = accountName;
-	setCoreParameter("AccountName", accountName);
+	setParameter("AccountName", accountName);
 }
 
 std::string BindAccountToClusterUserRequest::getAccountUid()const
@@ -79,7 +79,7 @@ std::string BindAccountToClusterUserRequest::getAccountUid()const
 void BindAccountToClusterUserRequest::setAccountUid(const std::string& accountUid)
 {
 	accountUid_ = accountUid;
-	setCoreParameter("AccountUid", accountUid);
+	setParameter("AccountUid", accountUid);
 }
 
 std::string BindAccountToClusterUserRequest::getUserName()const
@@ -90,6 +90,6 @@ std::string BindAccountToClusterUserRequest::getUserName()const
 void BindAccountToClusterUserRequest::setUserName(const std::string& userName)
 {
 	userName_ = userName;
-	setCoreParameter("UserName", userName);
+	setParameter("UserName", userName);
 }
 

ehpc/src/model/CreateClusterRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::CreateClusterRequest;
 CreateClusterRequest::CreateClusterRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "CreateCluster")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 CreateClusterRequest::~CreateClusterRequest()
@@ -37,20 +37,20 @@ void CreateClusterRequest::setAdditionalVolumes(const std::vector<AdditionalVolu
 	additionalVolumes_ = additionalVolumes;
 	for(int dep1 = 0; dep1!= additionalVolumes.size(); dep1++) {
 		auto additionalVolumesObj = additionalVolumes.at(dep1);
-		std::string additionalVolumesObjStr = "AdditionalVolumes." + std::to_string(dep1);
-		setCoreParameter(additionalVolumesObjStr + ".VolumeType", additionalVolumesObj.volumeType);
-		setCoreParameter(additionalVolumesObjStr + ".VolumeProtocol", additionalVolumesObj.volumeProtocol);
-		setCoreParameter(additionalVolumesObjStr + ".LocalDirectory", additionalVolumesObj.localDirectory);
-		setCoreParameter(additionalVolumesObjStr + ".RemoteDirectory", additionalVolumesObj.remoteDirectory);
+		std::string additionalVolumesObjStr = "AdditionalVolumes." + std::to_string(dep1 + 1);
+		setParameter(additionalVolumesObjStr + ".VolumeType", additionalVolumesObj.volumeType);
+		setParameter(additionalVolumesObjStr + ".VolumeProtocol", additionalVolumesObj.volumeProtocol);
+		setParameter(additionalVolumesObjStr + ".LocalDirectory", additionalVolumesObj.localDirectory);
+		setParameter(additionalVolumesObjStr + ".RemoteDirectory", additionalVolumesObj.remoteDirectory);
 		for(int dep2 = 0; dep2!= additionalVolumesObj.roles.size(); dep2++) {
 			auto rolesObj = additionalVolumesObj.roles.at(dep2);
-			std::string rolesObjStr = additionalVolumesObjStr + "Roles." + std::to_string(dep2);
-			setCoreParameter(rolesObjStr + ".Name", rolesObj.name);
+			std::string rolesObjStr = additionalVolumesObjStr + "Roles." + std::to_string(dep2 + 1);
+			setParameter(rolesObjStr + ".Name", rolesObj.name);
 		}
-		setCoreParameter(additionalVolumesObjStr + ".VolumeId", additionalVolumesObj.volumeId);
-		setCoreParameter(additionalVolumesObjStr + ".VolumeMountpoint", additionalVolumesObj.volumeMountpoint);
-		setCoreParameter(additionalVolumesObjStr + ".Location", additionalVolumesObj.location);
-		setCoreParameter(additionalVolumesObjStr + ".JobQueue", additionalVolumesObj.jobQueue);
+		setParameter(additionalVolumesObjStr + ".VolumeId", additionalVolumesObj.volumeId);
+		setParameter(additionalVolumesObjStr + ".VolumeMountpoint", additionalVolumesObj.volumeMountpoint);
+		setParameter(additionalVolumesObjStr + ".Location", additionalVolumesObj.location);
+		setParameter(additionalVolumesObjStr + ".JobQueue", additionalVolumesObj.jobQueue);
 	}
 }
 
@@ -62,7 +62,7 @@ std::string CreateClusterRequest::getEcsOrderManagerInstanceType()const
 void CreateClusterRequest::setEcsOrderManagerInstanceType(const std::string& ecsOrderManagerInstanceType)
 {
 	ecsOrderManagerInstanceType_ = ecsOrderManagerInstanceType;
-	setCoreParameter("EcsOrderManagerInstanceType", ecsOrderManagerInstanceType);
+	setParameter("EcsOrderManagerInstanceType", ecsOrderManagerInstanceType);
 }
 
 std::string CreateClusterRequest::getKeyPairName()const
@@ -73,7 +73,7 @@ std::string CreateClusterRequest::getKeyPairName()const
 void CreateClusterRequest::setKeyPairName(const std::string& keyPairName)
 {
 	keyPairName_ = keyPairName;
-	setCoreParameter("KeyPairName", keyPairName);
+	setParameter("KeyPairName", keyPairName);
 }
 
 std::string CreateClusterRequest::getSecurityGroupName()const
@@ -84,7 +84,7 @@ std::string CreateClusterRequest::getSecurityGroupName()const
 void CreateClusterRequest::setSecurityGroupName(const std::string& securityGroupName)
 {
 	securityGroupName_ = securityGroupName;
-	setCoreParameter("SecurityGroupName", securityGroupName);
+	setParameter("SecurityGroupName", securityGroupName);
 }
 
 std::string CreateClusterRequest::getImageOwnerAlias()const
@@ -95,7 +95,7 @@ std::string CreateClusterRequest::getImageOwnerAlias()const
 void CreateClusterRequest::setImageOwnerAlias(const std::string& imageOwnerAlias)
 {
 	imageOwnerAlias_ = imageOwnerAlias;
-	setCoreParameter("ImageOwnerAlias", imageOwnerAlias);
+	setParameter("ImageOwnerAlias", imageOwnerAlias);
 }
 
 std::string CreateClusterRequest::getDeployMode()const
@@ -106,7 +106,7 @@ std::string CreateClusterRequest::getDeployMode()const
 void CreateClusterRequest::setDeployMode(const std::string& deployMode)
 {
 	deployMode_ = deployMode;
-	setCoreParameter("DeployMode", deployMode);
+	setParameter("DeployMode", deployMode);
 }
 
 int CreateClusterRequest::getEcsOrderManagerCount()const
@@ -117,7 +117,7 @@ int CreateClusterRequest::getEcsOrderManagerCount()const
 void CreateClusterRequest::setEcsOrderManagerCount(int ecsOrderManagerCount)
 {
 	ecsOrderManagerCount_ = ecsOrderManagerCount;
-	setCoreParameter("EcsOrderManagerCount", std::to_string(ecsOrderManagerCount));
+	setParameter("EcsOrderManagerCount", std::to_string(ecsOrderManagerCount));
 }
 
 std::string CreateClusterRequest::getResourceGroupId()const
@@ -128,7 +128,7 @@ std::string CreateClusterRequest::getResourceGroupId()const
 void CreateClusterRequest::setResourceGroupId(const std::string& resourceGroupId)
 {
 	resourceGroupId_ = resourceGroupId;
-	setCoreParameter("ResourceGroupId", resourceGroupId);
+	setParameter("ResourceGroupId", resourceGroupId);
 }
 
 std::string CreateClusterRequest::getPassword()const
@@ -139,7 +139,7 @@ std::string CreateClusterRequest::getPassword()const
 void CreateClusterRequest::setPassword(const std::string& password)
 {
 	password_ = password;
-	setCoreParameter("Password", password);
+	setParameter("Password", password);
 }
 
 int CreateClusterRequest::getEcsOrderLoginCount()const
@@ -150,7 +150,7 @@ int CreateClusterRequest::getEcsOrderLoginCount()const
 void CreateClusterRequest::setEcsOrderLoginCount(int ecsOrderLoginCount)
 {
 	ecsOrderLoginCount_ = ecsOrderLoginCount;
-	setCoreParameter("EcsOrderLoginCount", std::to_string(ecsOrderLoginCount));
+	setParameter("EcsOrderLoginCount", std::to_string(ecsOrderLoginCount));
 }
 
 std::string CreateClusterRequest::getRemoteVisEnable()const
@@ -161,7 +161,7 @@ std::string CreateClusterRequest::getRemoteVisEnable()const
 void CreateClusterRequest::setRemoteVisEnable(const std::string& remoteVisEnable)
 {
 	remoteVisEnable_ = remoteVisEnable;
-	setCoreParameter("RemoteVisEnable", remoteVisEnable);
+	setParameter("RemoteVisEnable", remoteVisEnable);
 }
 
 int CreateClusterRequest::getSystemDiskSize()const
@@ -172,7 +172,7 @@ int CreateClusterRequest::getSystemDiskSize()const
 void CreateClusterRequest::setSystemDiskSize(int systemDiskSize)
 {
 	systemDiskSize_ = systemDiskSize;
-	setCoreParameter("SystemDiskSize", std::to_string(systemDiskSize));
+	setParameter("SystemDiskSize", std::to_string(systemDiskSize));
 }
 
 std::string CreateClusterRequest::getComputeSpotPriceLimit()const
@@ -183,7 +183,7 @@ std::string CreateClusterRequest::getComputeSpotPriceLimit()const
 void CreateClusterRequest::setComputeSpotPriceLimit(const std::string& computeSpotPriceLimit)
 {
 	computeSpotPriceLimit_ = computeSpotPriceLimit;
-	setCoreParameter("ComputeSpotPriceLimit", computeSpotPriceLimit);
+	setParameter("ComputeSpotPriceLimit", computeSpotPriceLimit);
 }
 
 int CreateClusterRequest::getAutoRenewPeriod()const
@@ -194,7 +194,7 @@ int CreateClusterRequest::getAutoRenewPeriod()const
 void CreateClusterRequest::setAutoRenewPeriod(int autoRenewPeriod)
 {
 	autoRenewPeriod_ = autoRenewPeriod;
-	setCoreParameter("AutoRenewPeriod", std::to_string(autoRenewPeriod));
+	setParameter("AutoRenewPeriod", std::to_string(autoRenewPeriod));
 }
 
 int CreateClusterRequest::getPeriod()const
@@ -205,7 +205,7 @@ int CreateClusterRequest::getPeriod()const
 void CreateClusterRequest::setPeriod(int period)
 {
 	period_ = period;
-	setCoreParameter("Period", std::to_string(period));
+	setParameter("Period", std::to_string(period));
 }
 
 std::string CreateClusterRequest::getRemoteDirectory()const
@@ -216,7 +216,7 @@ std::string CreateClusterRequest::getRemoteDirectory()const
 void CreateClusterRequest::setRemoteDirectory(const std::string& remoteDirectory)
 {
 	remoteDirectory_ = remoteDirectory;
-	setCoreParameter("RemoteDirectory", remoteDirectory);
+	setParameter("RemoteDirectory", remoteDirectory);
 }
 
 int CreateClusterRequest::getEcsOrderComputeCount()const
@@ -227,7 +227,7 @@ int CreateClusterRequest::getEcsOrderComputeCount()const
 void CreateClusterRequest::setEcsOrderComputeCount(int ecsOrderComputeCount)
 {
 	ecsOrderComputeCount_ = ecsOrderComputeCount;
-	setCoreParameter("EcsOrderComputeCount", std::to_string(ecsOrderComputeCount));
+	setParameter("EcsOrderComputeCount", std::to_string(ecsOrderComputeCount));
 }
 
 std::string CreateClusterRequest::getComputeSpotStrategy()const
@@ -238,7 +238,7 @@ std::string CreateClusterRequest::getComputeSpotStrategy()const
 void CreateClusterRequest::setComputeSpotStrategy(const std::string& computeSpotStrategy)
 {
 	computeSpotStrategy_ = computeSpotStrategy;
-	setCoreParameter("ComputeSpotStrategy", computeSpotStrategy);
+	setParameter("ComputeSpotStrategy", computeSpotStrategy);
 }
 
 std::vector<CreateClusterRequest::PostInstallScript> CreateClusterRequest::getPostInstallScript()const
@@ -251,9 +251,9 @@ void CreateClusterRequest::setPostInstallScript(const std::vector<PostInstallScr
 	postInstallScript_ = postInstallScript;
 	for(int dep1 = 0; dep1!= postInstallScript.size(); dep1++) {
 		auto postInstallScriptObj = postInstallScript.at(dep1);
-		std::string postInstallScriptObjStr = "PostInstallScript." + std::to_string(dep1);
-		setCoreParameter(postInstallScriptObjStr + ".Args", postInstallScriptObj.args);
-		setCoreParameter(postInstallScriptObjStr + ".Url", postInstallScriptObj.url);
+		std::string postInstallScriptObjStr = "PostInstallScript." + std::to_string(dep1 + 1);
+		setParameter(postInstallScriptObjStr + ".Args", postInstallScriptObj.args);
+		setParameter(postInstallScriptObjStr + ".Url", postInstallScriptObj.url);
 	}
 }
 
@@ -265,7 +265,7 @@ std::string CreateClusterRequest::getVSwitchId()const
 void CreateClusterRequest::setVSwitchId(const std::string& vSwitchId)
 {
 	vSwitchId_ = vSwitchId;
-	setCoreParameter("VSwitchId", vSwitchId);
+	setParameter("VSwitchId", vSwitchId);
 }
 
 std::string CreateClusterRequest::getPeriodUnit()const
@@ -276,7 +276,7 @@ std::string CreateClusterRequest::getPeriodUnit()const
 void CreateClusterRequest::setPeriodUnit(const std::string& periodUnit)
 {
 	periodUnit_ = periodUnit;
-	setCoreParameter("PeriodUnit", periodUnit);
+	setParameter("PeriodUnit", periodUnit);
 }
 
 bool CreateClusterRequest::getComputeEnableHt()const
@@ -287,7 +287,7 @@ bool CreateClusterRequest::getComputeEnableHt()const
 void CreateClusterRequest::setComputeEnableHt(bool computeEnableHt)
 {
 	computeEnableHt_ = computeEnableHt;
-	setCoreParameter("ComputeEnableHt", computeEnableHt ? "true" : "false");
+	setParameter("ComputeEnableHt", computeEnableHt ? "true" : "false");
 }
 
 std::string CreateClusterRequest::getAutoRenew()const
@@ -298,7 +298,7 @@ std::string CreateClusterRequest::getAutoRenew()const
 void CreateClusterRequest::setAutoRenew(const std::string& autoRenew)
 {
 	autoRenew_ = autoRenew;
-	setCoreParameter("AutoRenew", autoRenew);
+	setParameter("AutoRenew", autoRenew);
 }
 
 std::string CreateClusterRequest::getName()const
@@ -309,7 +309,7 @@ std::string CreateClusterRequest::getName()const
 void CreateClusterRequest::setName(const std::string& name)
 {
 	name_ = name;
-	setCoreParameter("Name", name);
+	setParameter("Name", name);
 }
 
 std::string CreateClusterRequest::getVolumeId()const
@@ -320,7 +320,7 @@ std::string CreateClusterRequest::getVolumeId()const
 void CreateClusterRequest::setVolumeId(const std::string& volumeId)
 {
 	volumeId_ = volumeId;
-	setCoreParameter("VolumeId", volumeId);
+	setParameter("VolumeId", volumeId);
 }
 
 std::string CreateClusterRequest::getZoneId()const
@@ -331,7 +331,7 @@ std::string CreateClusterRequest::getZoneId()const
 void CreateClusterRequest::setZoneId(const std::string& zoneId)
 {
 	zoneId_ = zoneId;
-	setCoreParameter("ZoneId", zoneId);
+	setParameter("ZoneId", zoneId);
 }
 
 std::string CreateClusterRequest::getSccClusterId()const
@@ -342,7 +342,7 @@ std::string CreateClusterRequest::getSccClusterId()const
 void CreateClusterRequest::setSccClusterId(const std::string& sccClusterId)
 {
 	sccClusterId_ = sccClusterId;
-	setCoreParameter("SccClusterId", sccClusterId);
+	setParameter("SccClusterId", sccClusterId);
 }
 
 std::string CreateClusterRequest::getImageId()const
@@ -353,7 +353,7 @@ std::string CreateClusterRequest::getImageId()const
 void CreateClusterRequest::setImageId(const std::string& imageId)
 {
 	imageId_ = imageId;
-	setCoreParameter("ImageId", imageId);
+	setParameter("ImageId", imageId);
 }
 
 std::string CreateClusterRequest::getEhpcVersion()const
@@ -364,7 +364,7 @@ std::string CreateClusterRequest::getEhpcVersion()const
 void CreateClusterRequest::setEhpcVersion(const std::string& ehpcVersion)
 {
 	ehpcVersion_ = ehpcVersion;
-	setCoreParameter("EhpcVersion", ehpcVersion);
+	setParameter("EhpcVersion", ehpcVersion);
 }
 
 std::string CreateClusterRequest::getAccountType()const
@@ -375,7 +375,7 @@ std::string CreateClusterRequest::getAccountType()const
 void CreateClusterRequest::setAccountType(const std::string& accountType)
 {
 	accountType_ = accountType;
-	setCoreParameter("AccountType", accountType);
+	setParameter("AccountType", accountType);
 }
 
 std::string CreateClusterRequest::getSecurityGroupId()const
@@ -386,7 +386,7 @@ std::string CreateClusterRequest::getSecurityGroupId()const
 void CreateClusterRequest::setSecurityGroupId(const std::string& securityGroupId)
 {
 	securityGroupId_ = securityGroupId;
-	setCoreParameter("SecurityGroupId", securityGroupId);
+	setParameter("SecurityGroupId", securityGroupId);
 }
 
 std::string CreateClusterRequest::getDescription()const
@@ -397,7 +397,7 @@ std::string CreateClusterRequest::getDescription()const
 void CreateClusterRequest::setDescription(const std::string& description)
 {
 	description_ = description;
-	setCoreParameter("Description", description);
+	setParameter("Description", description);
 }
 
 std::string CreateClusterRequest::getEcsOrderComputeInstanceType()const
@@ -408,7 +408,7 @@ std::string CreateClusterRequest::getEcsOrderComputeInstanceType()const
 void CreateClusterRequest::setEcsOrderComputeInstanceType(const std::string& ecsOrderComputeInstanceType)
 {
 	ecsOrderComputeInstanceType_ = ecsOrderComputeInstanceType;
-	setCoreParameter("EcsOrderComputeInstanceType", ecsOrderComputeInstanceType);
+	setParameter("EcsOrderComputeInstanceType", ecsOrderComputeInstanceType);
 }
 
 std::string CreateClusterRequest::getJobQueue()const
@@ -419,7 +419,7 @@ std::string CreateClusterRequest::getJobQueue()const
 void CreateClusterRequest::setJobQueue(const std::string& jobQueue)
 {
 	jobQueue_ = jobQueue;
-	setCoreParameter("JobQueue", jobQueue);
+	setParameter("JobQueue", jobQueue);
 }
 
 std::string CreateClusterRequest::getAccessKeyId()const
@@ -430,7 +430,7 @@ std::string CreateClusterRequest::getAccessKeyId()const
 void CreateClusterRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateClusterRequest::getVolumeType()const
@@ -441,7 +441,7 @@ std::string CreateClusterRequest::getVolumeType()const
 void CreateClusterRequest::setVolumeType(const std::string& volumeType)
 {
 	volumeType_ = volumeType;
-	setCoreParameter("VolumeType", volumeType);
+	setParameter("VolumeType", volumeType);
 }
 
 std::string CreateClusterRequest::getSystemDiskType()const
@@ -452,7 +452,7 @@ std::string CreateClusterRequest::getSystemDiskType()const
 void CreateClusterRequest::setSystemDiskType(const std::string& systemDiskType)
 {
 	systemDiskType_ = systemDiskType;
-	setCoreParameter("SystemDiskType", systemDiskType);
+	setParameter("SystemDiskType", systemDiskType);
 }
 
 std::string CreateClusterRequest::getVolumeProtocol()const
@@ -463,7 +463,7 @@ std::string CreateClusterRequest::getVolumeProtocol()const
 void CreateClusterRequest::setVolumeProtocol(const std::string& volumeProtocol)
 {
 	volumeProtocol_ = volumeProtocol;
-	setCoreParameter("VolumeProtocol", volumeProtocol);
+	setParameter("VolumeProtocol", volumeProtocol);
 }
 
 std::string CreateClusterRequest::getClientVersion()const
@@ -474,7 +474,7 @@ std::string CreateClusterRequest::getClientVersion()const
 void CreateClusterRequest::setClientVersion(const std::string& clientVersion)
 {
 	clientVersion_ = clientVersion;
-	setCoreParameter("ClientVersion", clientVersion);
+	setParameter("ClientVersion", clientVersion);
 }
 
 std::string CreateClusterRequest::getOsTag()const
@@ -485,7 +485,7 @@ std::string CreateClusterRequest::getOsTag()const
 void CreateClusterRequest::setOsTag(const std::string& osTag)
 {
 	osTag_ = osTag;
-	setCoreParameter("OsTag", osTag);
+	setParameter("OsTag", osTag);
 }
 
 std::vector<CreateClusterRequest::Application> CreateClusterRequest::getApplication()const
@@ -498,8 +498,8 @@ void CreateClusterRequest::setApplication(const std::vector<Application>& applic
 	application_ = application;
 	for(int dep1 = 0; dep1!= application.size(); dep1++) {
 		auto applicationObj = application.at(dep1);
-		std::string applicationObjStr = "Application." + std::to_string(dep1);
-		setCoreParameter(applicationObjStr + ".Tag", applicationObj.tag);
+		std::string applicationObjStr = "Application." + std::to_string(dep1 + 1);
+		setParameter(applicationObjStr + ".Tag", applicationObj.tag);
 	}
 }
 
@@ -511,7 +511,7 @@ std::string CreateClusterRequest::getEcsChargeType()const
 void CreateClusterRequest::setEcsChargeType(const std::string& ecsChargeType)
 {
 	ecsChargeType_ = ecsChargeType;
-	setCoreParameter("EcsChargeType", ecsChargeType);
+	setParameter("EcsChargeType", ecsChargeType);
 }
 
 std::string CreateClusterRequest::getInputFileUrl()const
@@ -522,7 +522,7 @@ std::string CreateClusterRequest::getInputFileUrl()const
 void CreateClusterRequest::setInputFileUrl(const std::string& inputFileUrl)
 {
 	inputFileUrl_ = inputFileUrl;
-	setCoreParameter("InputFileUrl", inputFileUrl);
+	setParameter("InputFileUrl", inputFileUrl);
 }
 
 std::string CreateClusterRequest::getVpcId()const
@@ -533,7 +533,7 @@ std::string CreateClusterRequest::getVpcId()const
 void CreateClusterRequest::setVpcId(const std::string& vpcId)
 {
 	vpcId_ = vpcId;
-	setCoreParameter("VpcId", vpcId);
+	setParameter("VpcId", vpcId);
 }
 
 bool CreateClusterRequest::getHaEnable()const
@@ -544,7 +544,7 @@ bool CreateClusterRequest::getHaEnable()const
 void CreateClusterRequest::setHaEnable(bool haEnable)
 {
 	haEnable_ = haEnable;
-	setCoreParameter("HaEnable", haEnable ? "true" : "false");
+	setParameter("HaEnable", haEnable ? "true" : "false");
 }
 
 std::string CreateClusterRequest::getSchedulerType()const
@@ -555,7 +555,7 @@ std::string CreateClusterRequest::getSchedulerType()const
 void CreateClusterRequest::setSchedulerType(const std::string& schedulerType)
 {
 	schedulerType_ = schedulerType;
-	setCoreParameter("SchedulerType", schedulerType);
+	setParameter("SchedulerType", schedulerType);
 }
 
 std::string CreateClusterRequest::getVolumeMountpoint()const
@@ -566,7 +566,7 @@ std::string CreateClusterRequest::getVolumeMountpoint()const
 void CreateClusterRequest::setVolumeMountpoint(const std::string& volumeMountpoint)
 {
 	volumeMountpoint_ = volumeMountpoint;
-	setCoreParameter("VolumeMountpoint", volumeMountpoint);
+	setParameter("VolumeMountpoint", volumeMountpoint);
 }
 
 std::string CreateClusterRequest::getEcsOrderLoginInstanceType()const
@@ -577,6 +577,6 @@ std::string CreateClusterRequest::getEcsOrderLoginInstanceType()const
 void CreateClusterRequest::setEcsOrderLoginInstanceType(const std::string& ecsOrderLoginInstanceType)
 {
 	ecsOrderLoginInstanceType_ = ecsOrderLoginInstanceType;
-	setCoreParameter("EcsOrderLoginInstanceType", ecsOrderLoginInstanceType);
+	setParameter("EcsOrderLoginInstanceType", ecsOrderLoginInstanceType);
 }
 

ehpc/src/model/CreateGWSClusterRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::CreateGWSClusterRequest;
 CreateGWSClusterRequest::CreateGWSClusterRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "CreateGWSCluster")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 CreateGWSClusterRequest::~CreateGWSClusterRequest()
@@ -35,7 +35,7 @@ std::string CreateGWSClusterRequest::getAccessKeyId()const
 void CreateGWSClusterRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateGWSClusterRequest::getClusterType()const
@@ -46,7 +46,7 @@ std::string CreateGWSClusterRequest::getClusterType()const
 void CreateGWSClusterRequest::setClusterType(const std::string& clusterType)
 {
 	clusterType_ = clusterType;
-	setCoreParameter("ClusterType", clusterType);
+	setParameter("ClusterType", clusterType);
 }
 
 std::string CreateGWSClusterRequest::getVpcId()const
@@ -57,7 +57,7 @@ std::string CreateGWSClusterRequest::getVpcId()const
 void CreateGWSClusterRequest::setVpcId(const std::string& vpcId)
 {
 	vpcId_ = vpcId;
-	setCoreParameter("VpcId", vpcId);
+	setParameter("VpcId", vpcId);
 }
 
 std::string CreateGWSClusterRequest::getName()const
@@ -68,6 +68,6 @@ std::string CreateGWSClusterRequest::getName()const
 void CreateGWSClusterRequest::setName(const std::string& name)
 {
 	name_ = name;
-	setCoreParameter("Name", name);
+	setParameter("Name", name);
 }
 

ehpc/src/model/CreateGWSImageRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::CreateGWSImageRequest;
 CreateGWSImageRequest::CreateGWSImageRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "CreateGWSImage")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 CreateGWSImageRequest::~CreateGWSImageRequest()
@@ -35,7 +35,7 @@ std::string CreateGWSImageRequest::getAccessKeyId()const
 void CreateGWSImageRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateGWSImageRequest::getInstanceId()const
@@ -46,7 +46,7 @@ std::string CreateGWSImageRequest::getInstanceId()const
 void CreateGWSImageRequest::setInstanceId(const std::string& instanceId)
 {
 	instanceId_ = instanceId;
-	setCoreParameter("InstanceId", instanceId);
+	setParameter("InstanceId", instanceId);
 }
 
 std::string CreateGWSImageRequest::getName()const
@@ -57,6 +57,6 @@ std::string CreateGWSImageRequest::getName()const
 void CreateGWSImageRequest::setName(const std::string& name)
 {
 	name_ = name;
-	setCoreParameter("Name", name);
+	setParameter("Name", name);
 }
 

ehpc/src/model/CreateGWSInstanceRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::CreateGWSInstanceRequest;
 CreateGWSInstanceRequest::CreateGWSInstanceRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "CreateGWSInstance")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 CreateGWSInstanceRequest::~CreateGWSInstanceRequest()
@@ -35,7 +35,7 @@ std::string CreateGWSInstanceRequest::getImageId()const
 void CreateGWSInstanceRequest::setImageId(const std::string& imageId)
 {
 	imageId_ = imageId;
-	setCoreParameter("ImageId", imageId);
+	setParameter("ImageId", imageId);
 }
 
 bool CreateGWSInstanceRequest::getAllocatePublicAddress()const
@@ -46,7 +46,7 @@ bool CreateGWSInstanceRequest::getAllocatePublicAddress()const
 void CreateGWSInstanceRequest::setAllocatePublicAddress(bool allocatePublicAddress)
 {
 	allocatePublicAddress_ = allocatePublicAddress;
-	setCoreParameter("AllocatePublicAddress", allocatePublicAddress ? "true" : "false");
+	setParameter("AllocatePublicAddress", allocatePublicAddress ? "true" : "false");
 }
 
 std::string CreateGWSInstanceRequest::getAppList()const
@@ -57,7 +57,7 @@ std::string CreateGWSInstanceRequest::getAppList()const
 void CreateGWSInstanceRequest::setAppList(const std::string& appList)
 {
 	appList_ = appList;
-	setCoreParameter("AppList", appList);
+	setParameter("AppList", appList);
 }
 
 int CreateGWSInstanceRequest::getInternetMaxBandwidthOut()const
@@ -68,7 +68,7 @@ int CreateGWSInstanceRequest::getInternetMaxBandwidthOut()const
 void CreateGWSInstanceRequest::setInternetMaxBandwidthOut(int internetMaxBandwidthOut)
 {
 	internetMaxBandwidthOut_ = internetMaxBandwidthOut;
-	setCoreParameter("InternetMaxBandwidthOut", std::to_string(internetMaxBandwidthOut));
+	setParameter("InternetMaxBandwidthOut", std::to_string(internetMaxBandwidthOut));
 }
 
 std::string CreateGWSInstanceRequest::getAccessKeyId()const
@@ -79,7 +79,7 @@ std::string CreateGWSInstanceRequest::getAccessKeyId()const
 void CreateGWSInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateGWSInstanceRequest::getSystemDiskCategory()const
@@ -90,7 +90,7 @@ std::string CreateGWSInstanceRequest::getSystemDiskCategory()const
 void CreateGWSInstanceRequest::setSystemDiskCategory(const std::string& systemDiskCategory)
 {
 	systemDiskCategory_ = systemDiskCategory;
-	setCoreParameter("SystemDiskCategory", systemDiskCategory);
+	setParameter("SystemDiskCategory", systemDiskCategory);
 }
 
 int CreateGWSInstanceRequest::getSystemDiskSize()const
@@ -101,7 +101,7 @@ int CreateGWSInstanceRequest::getSystemDiskSize()const
 void CreateGWSInstanceRequest::setSystemDiskSize(int systemDiskSize)
 {
 	systemDiskSize_ = systemDiskSize;
-	setCoreParameter("SystemDiskSize", std::to_string(systemDiskSize));
+	setParameter("SystemDiskSize", std::to_string(systemDiskSize));
 }
 
 std::string CreateGWSInstanceRequest::getInstanceType()const
@@ -112,7 +112,7 @@ std::string CreateGWSInstanceRequest::getInstanceType()const
 void CreateGWSInstanceRequest::setInstanceType(const std::string& instanceType)
 {
 	instanceType_ = instanceType;
-	setCoreParameter("InstanceType", instanceType);
+	setParameter("InstanceType", instanceType);
 }
 
 std::string CreateGWSInstanceRequest::getInstanceChargeType()const
@@ -123,7 +123,7 @@ std::string CreateGWSInstanceRequest::getInstanceChargeType()const
 void CreateGWSInstanceRequest::setInstanceChargeType(const std::string& instanceChargeType)
 {
 	instanceChargeType_ = instanceChargeType;
-	setCoreParameter("InstanceChargeType", instanceChargeType);
+	setParameter("InstanceChargeType", instanceChargeType);
 }
 
 std::string CreateGWSInstanceRequest::getPeriod()const
@@ -134,7 +134,7 @@ std::string CreateGWSInstanceRequest::getPeriod()const
 void CreateGWSInstanceRequest::setPeriod(const std::string& period)
 {
 	period_ = period;
-	setCoreParameter("Period", period);
+	setParameter("Period", period);
 }
 
 std::string CreateGWSInstanceRequest::getClusterId()const
@@ -145,7 +145,7 @@ std::string CreateGWSInstanceRequest::getClusterId()const
 void CreateGWSInstanceRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string CreateGWSInstanceRequest::getWorkMode()const
@@ -156,7 +156,7 @@ std::string CreateGWSInstanceRequest::getWorkMode()const
 void CreateGWSInstanceRequest::setWorkMode(const std::string& workMode)
 {
 	workMode_ = workMode;
-	setCoreParameter("WorkMode", workMode);
+	setParameter("WorkMode", workMode);
 }
 
 std::string CreateGWSInstanceRequest::getPeriodUnit()const
@@ -167,7 +167,7 @@ std::string CreateGWSInstanceRequest::getPeriodUnit()const
 void CreateGWSInstanceRequest::setPeriodUnit(const std::string& periodUnit)
 {
 	periodUnit_ = periodUnit;
-	setCoreParameter("PeriodUnit", periodUnit);
+	setParameter("PeriodUnit", periodUnit);
 }
 
 bool CreateGWSInstanceRequest::getAutoRenew()const
@@ -178,7 +178,7 @@ bool CreateGWSInstanceRequest::getAutoRenew()const
 void CreateGWSInstanceRequest::setAutoRenew(bool autoRenew)
 {
 	autoRenew_ = autoRenew;
-	setCoreParameter("AutoRenew", autoRenew ? "true" : "false");
+	setParameter("AutoRenew", autoRenew ? "true" : "false");
 }
 
 std::string CreateGWSInstanceRequest::getInternetChargeType()const
@@ -189,7 +189,7 @@ std::string CreateGWSInstanceRequest::getInternetChargeType()const
 void CreateGWSInstanceRequest::setInternetChargeType(const std::string& internetChargeType)
 {
 	internetChargeType_ = internetChargeType;
-	setCoreParameter("InternetChargeType", internetChargeType);
+	setParameter("InternetChargeType", internetChargeType);
 }
 
 std::string CreateGWSInstanceRequest::getName()const
@@ -200,7 +200,7 @@ std::string CreateGWSInstanceRequest::getName()const
 void CreateGWSInstanceRequest::setName(const std::string& name)
 {
 	name_ = name;
-	setCoreParameter("Name", name);
+	setParameter("Name", name);
 }
 
 int CreateGWSInstanceRequest::getInternetMaxBandwidthIn()const
@@ -211,6 +211,6 @@ int CreateGWSInstanceRequest::getInternetMaxBandwidthIn()const
 void CreateGWSInstanceRequest::setInternetMaxBandwidthIn(int internetMaxBandwidthIn)
 {
 	internetMaxBandwidthIn_ = internetMaxBandwidthIn;
-	setCoreParameter("InternetMaxBandwidthIn", std::to_string(internetMaxBandwidthIn));
+	setParameter("InternetMaxBandwidthIn", std::to_string(internetMaxBandwidthIn));
 }
 

ehpc/src/model/CreateHybridClusterRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::CreateHybridClusterRequest;
 CreateHybridClusterRequest::CreateHybridClusterRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "CreateHybridCluster")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 CreateHybridClusterRequest::~CreateHybridClusterRequest()
@@ -35,7 +35,7 @@ std::string CreateHybridClusterRequest::getEhpcVersion()const
 void CreateHybridClusterRequest::setEhpcVersion(const std::string& ehpcVersion)
 {
 	ehpcVersion_ = ehpcVersion;
-	setCoreParameter("EhpcVersion", ehpcVersion);
+	setParameter("EhpcVersion", ehpcVersion);
 }
 
 std::string CreateHybridClusterRequest::getSecurityGroupId()const
@@ -46,7 +46,7 @@ std::string CreateHybridClusterRequest::getSecurityGroupId()const
 void CreateHybridClusterRequest::setSecurityGroupId(const std::string& securityGroupId)
 {
 	securityGroupId_ = securityGroupId;
-	setCoreParameter("SecurityGroupId", securityGroupId);
+	setParameter("SecurityGroupId", securityGroupId);
 }
 
 std::string CreateHybridClusterRequest::getDescription()const
@@ -57,7 +57,7 @@ std::string CreateHybridClusterRequest::getDescription()const
 void CreateHybridClusterRequest::setDescription(const std::string& description)
 {
 	description_ = description;
-	setCoreParameter("Description", description);
+	setParameter("Description", description);
 }
 
 std::string CreateHybridClusterRequest::getKeyPairName()const
@@ -68,7 +68,7 @@ std::string CreateHybridClusterRequest::getKeyPairName()const
 void CreateHybridClusterRequest::setKeyPairName(const std::string& keyPairName)
 {
 	keyPairName_ = keyPairName;
-	setCoreParameter("KeyPairName", keyPairName);
+	setParameter("KeyPairName", keyPairName);
 }
 
 std::string CreateHybridClusterRequest::getSecurityGroupName()const
@@ -79,7 +79,7 @@ std::string CreateHybridClusterRequest::getSecurityGroupName()const
 void CreateHybridClusterRequest::setSecurityGroupName(const std::string& securityGroupName)
 {
 	securityGroupName_ = securityGroupName;
-	setCoreParameter("SecurityGroupName", securityGroupName);
+	setParameter("SecurityGroupName", securityGroupName);
 }
 
 std::string CreateHybridClusterRequest::getEcsOrderComputeInstanceType()const
@@ -90,7 +90,7 @@ std::string CreateHybridClusterRequest::getEcsOrderComputeInstanceType()const
 void CreateHybridClusterRequest::setEcsOrderComputeInstanceType(const std::string& ecsOrderComputeInstanceType)
 {
 	ecsOrderComputeInstanceType_ = ecsOrderComputeInstanceType;
-	setCoreParameter("EcsOrderComputeInstanceType", ecsOrderComputeInstanceType);
+	setParameter("EcsOrderComputeInstanceType", ecsOrderComputeInstanceType);
 }
 
 std::string CreateHybridClusterRequest::getOnPremiseVolumeRemotePath()const
@@ -101,7 +101,7 @@ std::string CreateHybridClusterRequest::getOnPremiseVolumeRemotePath()const
 void CreateHybridClusterRequest::setOnPremiseVolumeRemotePath(const std::string& onPremiseVolumeRemotePath)
 {
 	onPremiseVolumeRemotePath_ = onPremiseVolumeRemotePath;
-	setCoreParameter("OnPremiseVolumeRemotePath", onPremiseVolumeRemotePath);
+	setParameter("OnPremiseVolumeRemotePath", onPremiseVolumeRemotePath);
 }
 
 std::string CreateHybridClusterRequest::getJobQueue()const
@@ -112,7 +112,7 @@ std::string CreateHybridClusterRequest::getJobQueue()const
 void CreateHybridClusterRequest::setJobQueue(const std::string& jobQueue)
 {
 	jobQueue_ = jobQueue;
-	setCoreParameter("JobQueue", jobQueue);
+	setParameter("JobQueue", jobQueue);
 }
 
 std::string CreateHybridClusterRequest::getAccessKeyId()const
@@ -123,7 +123,7 @@ std::string CreateHybridClusterRequest::getAccessKeyId()const
 void CreateHybridClusterRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateHybridClusterRequest::getVolumeType()const
@@ -134,7 +134,7 @@ std::string CreateHybridClusterRequest::getVolumeType()const
 void CreateHybridClusterRequest::setVolumeType(const std::string& volumeType)
 {
 	volumeType_ = volumeType;
-	setCoreParameter("VolumeType", volumeType);
+	setParameter("VolumeType", volumeType);
 }
 
 std::string CreateHybridClusterRequest::getResourceGroupId()const
@@ -145,7 +145,7 @@ std::string CreateHybridClusterRequest::getResourceGroupId()const
 void CreateHybridClusterRequest::setResourceGroupId(const std::string& resourceGroupId)
 {
 	resourceGroupId_ = resourceGroupId;
-	setCoreParameter("ResourceGroupId", resourceGroupId);
+	setParameter("ResourceGroupId", resourceGroupId);
 }
 
 std::string CreateHybridClusterRequest::getPassword()const
@@ -156,7 +156,7 @@ std::string CreateHybridClusterRequest::getPassword()const
 void CreateHybridClusterRequest::setPassword(const std::string& password)
 {
 	password_ = password;
-	setCoreParameter("Password", password);
+	setParameter("Password", password);
 }
 
 std::string CreateHybridClusterRequest::getOnPremiseVolumeMountPoint()const
@@ -167,7 +167,7 @@ std::string CreateHybridClusterRequest::getOnPremiseVolumeMountPoint()const
 void CreateHybridClusterRequest::setOnPremiseVolumeMountPoint(const std::string& onPremiseVolumeMountPoint)
 {
 	onPremiseVolumeMountPoint_ = onPremiseVolumeMountPoint;
-	setCoreParameter("OnPremiseVolumeMountPoint", onPremiseVolumeMountPoint);
+	setParameter("OnPremiseVolumeMountPoint", onPremiseVolumeMountPoint);
 }
 
 std::string CreateHybridClusterRequest::getOnPremiseVolumeProtocol()const
@@ -178,7 +178,7 @@ std::string CreateHybridClusterRequest::getOnPremiseVolumeProtocol()const
 void CreateHybridClusterRequest::setOnPremiseVolumeProtocol(const std::string& onPremiseVolumeProtocol)
 {
 	onPremiseVolumeProtocol_ = onPremiseVolumeProtocol;
-	setCoreParameter("OnPremiseVolumeProtocol", onPremiseVolumeProtocol);
+	setParameter("OnPremiseVolumeProtocol", onPremiseVolumeProtocol);
 }
 
 std::string CreateHybridClusterRequest::getVolumeProtocol()const
@@ -189,7 +189,7 @@ std::string CreateHybridClusterRequest::getVolumeProtocol()const
 void CreateHybridClusterRequest::setVolumeProtocol(const std::string& volumeProtocol)
 {
 	volumeProtocol_ = volumeProtocol;
-	setCoreParameter("VolumeProtocol", volumeProtocol);
+	setParameter("VolumeProtocol", volumeProtocol);
 }
 
 std::string CreateHybridClusterRequest::getOnPremiseVolumeLocalPath()const
@@ -200,7 +200,7 @@ std::string CreateHybridClusterRequest::getOnPremiseVolumeLocalPath()const
 void CreateHybridClusterRequest::setOnPremiseVolumeLocalPath(const std::string& onPremiseVolumeLocalPath)
 {
 	onPremiseVolumeLocalPath_ = onPremiseVolumeLocalPath;
-	setCoreParameter("OnPremiseVolumeLocalPath", onPremiseVolumeLocalPath);
+	setParameter("OnPremiseVolumeLocalPath", onPremiseVolumeLocalPath);
 }
 
 std::string CreateHybridClusterRequest::getClientVersion()const
@@ -211,7 +211,7 @@ std::string CreateHybridClusterRequest::getClientVersion()const
 void CreateHybridClusterRequest::setClientVersion(const std::string& clientVersion)
 {
 	clientVersion_ = clientVersion;
-	setCoreParameter("ClientVersion", clientVersion);
+	setParameter("ClientVersion", clientVersion);
 }
 
 std::string CreateHybridClusterRequest::getOsTag()const
@@ -222,7 +222,7 @@ std::string CreateHybridClusterRequest::getOsTag()const
 void CreateHybridClusterRequest::setOsTag(const std::string& osTag)
 {
 	osTag_ = osTag;
-	setCoreParameter("OsTag", osTag);
+	setParameter("OsTag", osTag);
 }
 
 std::string CreateHybridClusterRequest::getRemoteDirectory()const
@@ -233,7 +233,7 @@ std::string CreateHybridClusterRequest::getRemoteDirectory()const
 void CreateHybridClusterRequest::setRemoteDirectory(const std::string& remoteDirectory)
 {
 	remoteDirectory_ = remoteDirectory;
-	setCoreParameter("RemoteDirectory", remoteDirectory);
+	setParameter("RemoteDirectory", remoteDirectory);
 }
 
 std::vector<CreateHybridClusterRequest::PostInstallScript> CreateHybridClusterRequest::getPostInstallScript()const
@@ -246,9 +246,9 @@ void CreateHybridClusterRequest::setPostInstallScript(const std::vector<PostInst
 	postInstallScript_ = postInstallScript;
 	for(int dep1 = 0; dep1!= postInstallScript.size(); dep1++) {
 		auto postInstallScriptObj = postInstallScript.at(dep1);
-		std::string postInstallScriptObjStr = "PostInstallScript." + std::to_string(dep1);
-		setCoreParameter(postInstallScriptObjStr + ".Args", postInstallScriptObj.args);
-		setCoreParameter(postInstallScriptObjStr + ".Url", postInstallScriptObj.url);
+		std::string postInstallScriptObjStr = "PostInstallScript." + std::to_string(dep1 + 1);
+		setParameter(postInstallScriptObjStr + ".Args", postInstallScriptObj.args);
+		setParameter(postInstallScriptObjStr + ".Url", postInstallScriptObj.url);
 	}
 }
 
@@ -260,7 +260,7 @@ std::string CreateHybridClusterRequest::getVSwitchId()const
 void CreateHybridClusterRequest::setVSwitchId(const std::string& vSwitchId)
 {
 	vSwitchId_ = vSwitchId;
-	setCoreParameter("VSwitchId", vSwitchId);
+	setParameter("VSwitchId", vSwitchId);
 }
 
 std::vector<CreateHybridClusterRequest::Nodes> CreateHybridClusterRequest::getNodes()const
@@ -273,12 +273,12 @@ void CreateHybridClusterRequest::setNodes(const std::vector<Nodes>& nodes)
 	nodes_ = nodes;
 	for(int dep1 = 0; dep1!= nodes.size(); dep1++) {
 		auto nodesObj = nodes.at(dep1);
-		std::string nodesObjStr = "Nodes." + std::to_string(dep1);
-		setCoreParameter(nodesObjStr + ".IpAddress", nodesObj.ipAddress);
-		setCoreParameter(nodesObjStr + ".HostName", nodesObj.hostName);
-		setCoreParameter(nodesObjStr + ".Role", nodesObj.role);
-		setCoreParameter(nodesObjStr + ".AccountType", nodesObj.accountType);
-		setCoreParameter(nodesObjStr + ".SchedulerType", nodesObj.schedulerType);
+		std::string nodesObjStr = "Nodes." + std::to_string(dep1 + 1);
+		setParameter(nodesObjStr + ".IpAddress", nodesObj.ipAddress);
+		setParameter(nodesObjStr + ".HostName", nodesObj.hostName);
+		setParameter(nodesObjStr + ".Role", nodesObj.role);
+		setParameter(nodesObjStr + ".AccountType", nodesObj.accountType);
+		setParameter(nodesObjStr + ".SchedulerType", nodesObj.schedulerType);
 	}
 }
 
@@ -292,8 +292,8 @@ void CreateHybridClusterRequest::setApplication(const std::vector<Application>&
 	application_ = application;
 	for(int dep1 = 0; dep1!= application.size(); dep1++) {
 		auto applicationObj = application.at(dep1);
-		std::string applicationObjStr = "Application." + std::to_string(dep1);
-		setCoreParameter(applicationObjStr + ".Tag", applicationObj.tag);
+		std::string applicationObjStr = "Application." + std::to_string(dep1 + 1);
+		setParameter(applicationObjStr + ".Tag", applicationObj.tag);
 	}
 }
 
@@ -305,7 +305,7 @@ std::string CreateHybridClusterRequest::getDomain()const
 void CreateHybridClusterRequest::setDomain(const std::string& domain)
 {
 	domain_ = domain;
-	setCoreParameter("Domain", domain);
+	setParameter("Domain", domain);
 }
 
 std::string CreateHybridClusterRequest::getVpcId()const
@@ -316,7 +316,7 @@ std::string CreateHybridClusterRequest::getVpcId()const
 void CreateHybridClusterRequest::setVpcId(const std::string& vpcId)
 {
 	vpcId_ = vpcId;
-	setCoreParameter("VpcId", vpcId);
+	setParameter("VpcId", vpcId);
 }
 
 std::string CreateHybridClusterRequest::getName()const
@@ -327,7 +327,7 @@ std::string CreateHybridClusterRequest::getName()const
 void CreateHybridClusterRequest::setName(const std::string& name)
 {
 	name_ = name;
-	setCoreParameter("Name", name);
+	setParameter("Name", name);
 }
 
 std::string CreateHybridClusterRequest::getVolumeId()const
@@ -338,7 +338,7 @@ std::string CreateHybridClusterRequest::getVolumeId()const
 void CreateHybridClusterRequest::setVolumeId(const std::string& volumeId)
 {
 	volumeId_ = volumeId;
-	setCoreParameter("VolumeId", volumeId);
+	setParameter("VolumeId", volumeId);
 }
 
 std::string CreateHybridClusterRequest::getVolumeMountpoint()const
@@ -349,7 +349,7 @@ std::string CreateHybridClusterRequest::getVolumeMountpoint()const
 void CreateHybridClusterRequest::setVolumeMountpoint(const std::string& volumeMountpoint)
 {
 	volumeMountpoint_ = volumeMountpoint;
-	setCoreParameter("VolumeMountpoint", volumeMountpoint);
+	setParameter("VolumeMountpoint", volumeMountpoint);
 }
 
 std::string CreateHybridClusterRequest::getZoneId()const
@@ -360,7 +360,7 @@ std::string CreateHybridClusterRequest::getZoneId()const
 void CreateHybridClusterRequest::setZoneId(const std::string& zoneId)
 {
 	zoneId_ = zoneId;
-	setCoreParameter("ZoneId", zoneId);
+	setParameter("ZoneId", zoneId);
 }
 
 bool CreateHybridClusterRequest::getSchedulerPreInstall()const
@@ -371,7 +371,7 @@ bool CreateHybridClusterRequest::getSchedulerPreInstall()const
 void CreateHybridClusterRequest::setSchedulerPreInstall(bool schedulerPreInstall)
 {
 	schedulerPreInstall_ = schedulerPreInstall;
-	setCoreParameter("SchedulerPreInstall", schedulerPreInstall ? "true" : "false");
+	setParameter("SchedulerPreInstall", schedulerPreInstall ? "true" : "false");
 }
 
 std::string CreateHybridClusterRequest::getLocation()const
@@ -382,6 +382,6 @@ std::string CreateHybridClusterRequest::getLocation()const
 void CreateHybridClusterRequest::setLocation(const std::string& location)
 {
 	location_ = location;
-	setCoreParameter("Location", location);
+	setParameter("Location", location);
 }
 

ehpc/src/model/CreateJobFileRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::CreateJobFileRequest;
 CreateJobFileRequest::CreateJobFileRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "CreateJobFile")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 CreateJobFileRequest::~CreateJobFileRequest()
@@ -35,7 +35,7 @@ std::string CreateJobFileRequest::getTargetFile()const
 void CreateJobFileRequest::setTargetFile(const std::string& targetFile)
 {
 	targetFile_ = targetFile;
-	setCoreParameter("TargetFile", targetFile);
+	setParameter("TargetFile", targetFile);
 }
 
 std::string CreateJobFileRequest::getRunasUserPassword()const
@@ -46,7 +46,7 @@ std::string CreateJobFileRequest::getRunasUserPassword()const
 void CreateJobFileRequest::setRunasUserPassword(const std::string& runasUserPassword)
 {
 	runasUserPassword_ = runasUserPassword;
-	setCoreParameter("RunasUserPassword", runasUserPassword);
+	setParameter("RunasUserPassword", runasUserPassword);
 }
 
 std::string CreateJobFileRequest::getRunasUser()const
@@ -57,7 +57,7 @@ std::string CreateJobFileRequest::getRunasUser()const
 void CreateJobFileRequest::setRunasUser(const std::string& runasUser)
 {
 	runasUser_ = runasUser;
-	setCoreParameter("RunasUser", runasUser);
+	setParameter("RunasUser", runasUser);
 }
 
 std::string CreateJobFileRequest::getClusterId()const
@@ -68,7 +68,7 @@ std::string CreateJobFileRequest::getClusterId()const
 void CreateJobFileRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string CreateJobFileRequest::getContent()const
@@ -79,7 +79,7 @@ std::string CreateJobFileRequest::getContent()const
 void CreateJobFileRequest::setContent(const std::string& content)
 {
 	content_ = content;
-	setCoreParameter("Content", content);
+	setParameter("Content", content);
 }
 
 std::string CreateJobFileRequest::getAccessKeyId()const
@@ -90,6 +90,6 @@ std::string CreateJobFileRequest::getAccessKeyId()const
 void CreateJobFileRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/CreateJobTemplateRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::CreateJobTemplateRequest;
 CreateJobTemplateRequest::CreateJobTemplateRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "CreateJobTemplate")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 CreateJobTemplateRequest::~CreateJobTemplateRequest()
@@ -35,7 +35,7 @@ std::string CreateJobTemplateRequest::getStderrRedirectPath()const
 void CreateJobTemplateRequest::setStderrRedirectPath(const std::string& stderrRedirectPath)
 {
 	stderrRedirectPath_ = stderrRedirectPath;
-	setCoreParameter("StderrRedirectPath", stderrRedirectPath);
+	setParameter("StderrRedirectPath", stderrRedirectPath);
 }
 
 std::string CreateJobTemplateRequest::getCommandLine()const
@@ -46,7 +46,7 @@ std::string CreateJobTemplateRequest::getCommandLine()const
 void CreateJobTemplateRequest::setCommandLine(const std::string& commandLine)
 {
 	commandLine_ = commandLine;
-	setCoreParameter("CommandLine", commandLine);
+	setParameter("CommandLine", commandLine);
 }
 
 std::string CreateJobTemplateRequest::getAccessKeyId()const
@@ -57,7 +57,7 @@ std::string CreateJobTemplateRequest::getAccessKeyId()const
 void CreateJobTemplateRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateJobTemplateRequest::getArrayRequest()const
@@ -68,7 +68,7 @@ std::string CreateJobTemplateRequest::getArrayRequest()const
 void CreateJobTemplateRequest::setArrayRequest(const std::string& arrayRequest)
 {
 	arrayRequest_ = arrayRequest;
-	setCoreParameter("ArrayRequest", arrayRequest);
+	setParameter("ArrayRequest", arrayRequest);
 }
 
 std::string CreateJobTemplateRequest::getPackagePath()const
@@ -79,7 +79,7 @@ std::string CreateJobTemplateRequest::getPackagePath()const
 void CreateJobTemplateRequest::setPackagePath(const std::string& packagePath)
 {
 	packagePath_ = packagePath;
-	setCoreParameter("PackagePath", packagePath);
+	setParameter("PackagePath", packagePath);
 }
 
 std::string CreateJobTemplateRequest::getStdoutRedirectPath()const
@@ -90,7 +90,7 @@ std::string CreateJobTemplateRequest::getStdoutRedirectPath()const
 void CreateJobTemplateRequest::setStdoutRedirectPath(const std::string& stdoutRedirectPath)
 {
 	stdoutRedirectPath_ = stdoutRedirectPath;
-	setCoreParameter("StdoutRedirectPath", stdoutRedirectPath);
+	setParameter("StdoutRedirectPath", stdoutRedirectPath);
 }
 
 std::string CreateJobTemplateRequest::getVariables()const
@@ -101,7 +101,7 @@ std::string CreateJobTemplateRequest::getVariables()const
 void CreateJobTemplateRequest::setVariables(const std::string& variables)
 {
 	variables_ = variables;
-	setCoreParameter("Variables", variables);
+	setParameter("Variables", variables);
 }
 
 std::string CreateJobTemplateRequest::getRunasUser()const
@@ -112,7 +112,7 @@ std::string CreateJobTemplateRequest::getRunasUser()const
 void CreateJobTemplateRequest::setRunasUser(const std::string& runasUser)
 {
 	runasUser_ = runasUser;
-	setCoreParameter("RunasUser", runasUser);
+	setParameter("RunasUser", runasUser);
 }
 
 bool CreateJobTemplateRequest::getReRunable()const
@@ -123,7 +123,7 @@ bool CreateJobTemplateRequest::getReRunable()const
 void CreateJobTemplateRequest::setReRunable(bool reRunable)
 {
 	reRunable_ = reRunable;
-	setCoreParameter("ReRunable", reRunable ? "true" : "false");
+	setParameter("ReRunable", reRunable ? "true" : "false");
 }
 
 int CreateJobTemplateRequest::getPriority()const
@@ -134,7 +134,7 @@ int CreateJobTemplateRequest::getPriority()const
 void CreateJobTemplateRequest::setPriority(int priority)
 {
 	priority_ = priority;
-	setCoreParameter("Priority", std::to_string(priority));
+	setParameter("Priority", std::to_string(priority));
 }
 
 std::string CreateJobTemplateRequest::getName()const
@@ -145,6 +145,6 @@ std::string CreateJobTemplateRequest::getName()const
 void CreateJobTemplateRequest::setName(const std::string& name)
 {
 	name_ = name;
-	setCoreParameter("Name", name);
+	setParameter("Name", name);
 }
 

ehpc/src/model/DeleteClusterRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::DeleteClusterRequest;
 DeleteClusterRequest::DeleteClusterRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "DeleteCluster")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 DeleteClusterRequest::~DeleteClusterRequest()
@@ -35,7 +35,7 @@ std::string DeleteClusterRequest::getClusterId()const
 void DeleteClusterRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string DeleteClusterRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string DeleteClusterRequest::getAccessKeyId()const
 void DeleteClusterRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DeleteClusterRequest::getReleaseInstance()const
@@ -57,6 +57,6 @@ std::string DeleteClusterRequest::getReleaseInstance()const
 void DeleteClusterRequest::setReleaseInstance(const std::string& releaseInstance)
 {
 	releaseInstance_ = releaseInstance;
-	setCoreParameter("ReleaseInstance", releaseInstance);
+	setParameter("ReleaseInstance", releaseInstance);
 }
 

ehpc/src/model/DeleteContainerAppsRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::DeleteContainerAppsRequest;
 DeleteContainerAppsRequest::DeleteContainerAppsRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "DeleteContainerApps")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 DeleteContainerAppsRequest::~DeleteContainerAppsRequest()
@@ -37,8 +37,8 @@ void DeleteContainerAppsRequest::setContainerApp(const std::vector<ContainerApp>
 	containerApp_ = containerApp;
 	for(int dep1 = 0; dep1!= containerApp.size(); dep1++) {
 		auto containerAppObj = containerApp.at(dep1);
-		std::string containerAppObjStr = "ContainerApp." + std::to_string(dep1);
-		setCoreParameter(containerAppObjStr + ".Id", containerAppObj.id);
+		std::string containerAppObjStr = "ContainerApp." + std::to_string(dep1 + 1);
+		setParameter(containerAppObjStr + ".Id", containerAppObj.id);
 	}
 }
 
@@ -50,6 +50,6 @@ std::string DeleteContainerAppsRequest::getAccessKeyId()const
 void DeleteContainerAppsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DeleteGWSClusterRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::DeleteGWSClusterRequest;
 DeleteGWSClusterRequest::DeleteGWSClusterRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "DeleteGWSCluster")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 DeleteGWSClusterRequest::~DeleteGWSClusterRequest()
@@ -35,7 +35,7 @@ std::string DeleteGWSClusterRequest::getClusterId()const
 void DeleteGWSClusterRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string DeleteGWSClusterRequest::getAccessKeyId()const
@@ -46,6 +46,6 @@ std::string DeleteGWSClusterRequest::getAccessKeyId()const
 void DeleteGWSClusterRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DeleteGWSInstanceRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::DeleteGWSInstanceRequest;
 DeleteGWSInstanceRequest::DeleteGWSInstanceRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "DeleteGWSInstance")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 DeleteGWSInstanceRequest::~DeleteGWSInstanceRequest()
@@ -35,7 +35,7 @@ std::string DeleteGWSInstanceRequest::getAccessKeyId()const
 void DeleteGWSInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DeleteGWSInstanceRequest::getInstanceId()const
@@ -46,6 +46,6 @@ std::string DeleteGWSInstanceRequest::getInstanceId()const
 void DeleteGWSInstanceRequest::setInstanceId(const std::string& instanceId)
 {
 	instanceId_ = instanceId;
-	setCoreParameter("InstanceId", instanceId);
+	setParameter("InstanceId", instanceId);
 }
 

ehpc/src/model/DeleteImageRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::DeleteImageRequest;
 DeleteImageRequest::DeleteImageRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "DeleteImage")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 DeleteImageRequest::~DeleteImageRequest()
@@ -35,7 +35,7 @@ std::string DeleteImageRequest::getClusterId()const
 void DeleteImageRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string DeleteImageRequest::getRepository()const
@@ -46,7 +46,7 @@ std::string DeleteImageRequest::getRepository()const
 void DeleteImageRequest::setRepository(const std::string& repository)
 {
 	repository_ = repository;
-	setCoreParameter("Repository", repository);
+	setParameter("Repository", repository);
 }
 
 std::string DeleteImageRequest::getAccessKeyId()const
@@ -57,7 +57,7 @@ std::string DeleteImageRequest::getAccessKeyId()const
 void DeleteImageRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DeleteImageRequest::getContainerType()const
@@ -68,7 +68,7 @@ std::string DeleteImageRequest::getContainerType()const
 void DeleteImageRequest::setContainerType(const std::string& containerType)
 {
 	containerType_ = containerType;
-	setCoreParameter("ContainerType", containerType);
+	setParameter("ContainerType", containerType);
 }
 
 std::string DeleteImageRequest::getImageTag()const
@@ -79,6 +79,6 @@ std::string DeleteImageRequest::getImageTag()const
 void DeleteImageRequest::setImageTag(const std::string& imageTag)
 {
 	imageTag_ = imageTag;
-	setCoreParameter("ImageTag", imageTag);
+	setParameter("ImageTag", imageTag);
 }
 

ehpc/src/model/DeleteJobTemplatesRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::DeleteJobTemplatesRequest;
 DeleteJobTemplatesRequest::DeleteJobTemplatesRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "DeleteJobTemplates")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 DeleteJobTemplatesRequest::~DeleteJobTemplatesRequest()
@@ -35,7 +35,7 @@ std::string DeleteJobTemplatesRequest::getTemplates()const
 void DeleteJobTemplatesRequest::setTemplates(const std::string& templates)
 {
 	templates_ = templates;
-	setCoreParameter("Templates", templates);
+	setParameter("Templates", templates);
 }
 
 std::string DeleteJobTemplatesRequest::getAccessKeyId()const
@@ -46,6 +46,6 @@ std::string DeleteJobTemplatesRequest::getAccessKeyId()const
 void DeleteJobTemplatesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DeleteJobsRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::DeleteJobsRequest;
 DeleteJobsRequest::DeleteJobsRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "DeleteJobs")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 DeleteJobsRequest::~DeleteJobsRequest()
@@ -35,7 +35,7 @@ std::string DeleteJobsRequest::getJobs()const
 void DeleteJobsRequest::setJobs(const std::string& jobs)
 {
 	jobs_ = jobs;
-	setCoreParameter("Jobs", jobs);
+	setParameter("Jobs", jobs);
 }
 
 std::string DeleteJobsRequest::getClusterId()const
@@ -46,7 +46,7 @@ std::string DeleteJobsRequest::getClusterId()const
 void DeleteJobsRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string DeleteJobsRequest::getAccessKeyId()const
@@ -57,6 +57,6 @@ std::string DeleteJobsRequest::getAccessKeyId()const
 void DeleteJobsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DeleteNodesRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::DeleteNodesRequest;
 DeleteNodesRequest::DeleteNodesRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "DeleteNodes")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 DeleteNodesRequest::~DeleteNodesRequest()
@@ -37,8 +37,8 @@ void DeleteNodesRequest::setInstance(const std::vector<Instance>& instance)
 	instance_ = instance;
 	for(int dep1 = 0; dep1!= instance.size(); dep1++) {
 		auto instanceObj = instance.at(dep1);
-		std::string instanceObjStr = "Instance." + std::to_string(dep1);
-		setCoreParameter(instanceObjStr + ".Id", instanceObj.id);
+		std::string instanceObjStr = "Instance." + std::to_string(dep1 + 1);
+		setParameter(instanceObjStr + ".Id", instanceObj.id);
 	}
 }
 
@@ -50,7 +50,7 @@ std::string DeleteNodesRequest::getClusterId()const
 void DeleteNodesRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string DeleteNodesRequest::getAccessKeyId()const
@@ -61,7 +61,7 @@ std::string DeleteNodesRequest::getAccessKeyId()const
 void DeleteNodesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 bool DeleteNodesRequest::getReleaseInstance()const
@@ -72,6 +72,6 @@ bool DeleteNodesRequest::getReleaseInstance()const
 void DeleteNodesRequest::setReleaseInstance(bool releaseInstance)
 {
 	releaseInstance_ = releaseInstance;
-	setCoreParameter("ReleaseInstance", releaseInstance ? "true" : "false");
+	setParameter("ReleaseInstance", releaseInstance ? "true" : "false");
 }
 

ehpc/src/model/DeleteQueueRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::DeleteQueueRequest;
 DeleteQueueRequest::DeleteQueueRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "DeleteQueue")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 DeleteQueueRequest::~DeleteQueueRequest()
@@ -35,7 +35,7 @@ std::string DeleteQueueRequest::getQueueName()const
 void DeleteQueueRequest::setQueueName(const std::string& queueName)
 {
 	queueName_ = queueName;
-	setCoreParameter("QueueName", queueName);
+	setParameter("QueueName", queueName);
 }
 
 std::string DeleteQueueRequest::getClusterId()const
@@ -46,7 +46,7 @@ std::string DeleteQueueRequest::getClusterId()const
 void DeleteQueueRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string DeleteQueueRequest::getAccessKeyId()const
@@ -57,6 +57,6 @@ std::string DeleteQueueRequest::getAccessKeyId()const
 void DeleteQueueRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DeleteUsersRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::DeleteUsersRequest;
 DeleteUsersRequest::DeleteUsersRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "DeleteUsers")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 DeleteUsersRequest::~DeleteUsersRequest()
@@ -35,7 +35,7 @@ std::string DeleteUsersRequest::getClusterId()const
 void DeleteUsersRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string DeleteUsersRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string DeleteUsersRequest::getAccessKeyId()const
 void DeleteUsersRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::vector<DeleteUsersRequest::User> DeleteUsersRequest::getUser()const
@@ -59,8 +59,8 @@ void DeleteUsersRequest::setUser(const std::vector<User>& user)
 	user_ = user;
 	for(int dep1 = 0; dep1!= user.size(); dep1++) {
 		auto userObj = user.at(dep1);
-		std::string userObjStr = "User." + std::to_string(dep1);
-		setCoreParameter(userObjStr + ".Name", userObj.name);
+		std::string userObjStr = "User." + std::to_string(dep1 + 1);
+		setParameter(userObjStr + ".Name", userObj.name);
 	}
 }
 

ehpc/src/model/DescribeAutoScaleConfigRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::DescribeAutoScaleConfigRequest;
 DescribeAutoScaleConfigRequest::DescribeAutoScaleConfigRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "DescribeAutoScaleConfig")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 DescribeAutoScaleConfigRequest::~DescribeAutoScaleConfigRequest()
@@ -35,7 +35,7 @@ std::string DescribeAutoScaleConfigRequest::getClusterId()const
 void DescribeAutoScaleConfigRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string DescribeAutoScaleConfigRequest::getAccessKeyId()const
@@ -46,6 +46,6 @@ std::string DescribeAutoScaleConfigRequest::getAccessKeyId()const
 void DescribeAutoScaleConfigRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DescribeClusterRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::DescribeClusterRequest;
 DescribeClusterRequest::DescribeClusterRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "DescribeCluster")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 DescribeClusterRequest::~DescribeClusterRequest()
@@ -35,7 +35,7 @@ std::string DescribeClusterRequest::getClusterId()const
 void DescribeClusterRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setCoreParameter("ClusterId", clusterId);
+	setParameter("ClusterId", clusterId);
 }
 
 std::string DescribeClusterRequest::getAccessKeyId()const
@@ -46,6 +46,6 @@ std::string DescribeClusterRequest::getAccessKeyId()const
 void DescribeClusterRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DescribeClusterResult.cc

@@ -92,6 +92,8 @@ void DescribeClusterResult::parse(const std::string &payload)
 		clusterInfo_.imageId = clusterInfoNode["ImageId"].asString();
 	if(!clusterInfoNode["Location"].isNull())
 		clusterInfo_.location = clusterInfoNode["Location"].asString();
+	if(!clusterInfoNode["BaseOsTag"].isNull())
+		clusterInfo_.baseOsTag = clusterInfoNode["BaseOsTag"].asString();
 	auto allApplicationsNode = clusterInfoNode["Applications"]["ApplicationInfo"];
 	for (auto clusterInfoNodeApplicationsApplicationInfo : allApplicationsNode)
 	{

ehpc/src/model/DescribeContainerAppRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::EHPC::Model::DescribeContainerAppRequest;
 DescribeContainerAppRequest::DescribeContainerAppRequest() :
 	RpcServiceRequest("ehpc", "2018-04-12", "DescribeContainerApp")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::GET);
 }
 
 DescribeContainerAppRequest::~DescribeContainerAppRequest()
@@ -35,7 +35,7 @@ std::string DescribeContainerAppRequest::getAccessKeyId()const
 void DescribeContainerAppRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeContainerAppRequest::getContainerId()const
@@ -46,6 +46,6 @@ std::string DescribeContainerAppRequest::getContainerId()const
 void DescribeContainerAppRequest::setContainerId(const std::string& containerId)
 {
 	containerId_ = containerId;
-	setCoreParameter("ContainerId", containerId);
+	setParameter("ContainerId", containerId);
 }