Edit SearchTraces api.

CHANGELOG

@@ -1,3 +1,54 @@
+2020-06-02 Version: 1.36.441
+- Edit SearchTraces api.
+
+2020-05-28 Version: 1.36.440
+- Supported AndroidNotificationXiaomiChannel for Push and MassPush.
+
+2020-05-27 Version: 1.36.439
+- Added cn-heyuan endpoint url.
+- Added cn-wulanchabu endpoint url.
+
+2020-05-27 Version: 1.36.438
+- Add support for create hbaseue multizone instance.
+
+2020-05-26 Version: 1.36.437
+- Support DescribeAllEntity API.
+
+2020-05-26 Version: 1.36.436
+- Add smartcall service api.
+
+2020-05-26 Version: 1.36.435
+- Add smartcall service api.
+
+2020-05-26 Version: 1.36.434
+- Add monitor related API.
+
+2020-05-26 Version: 1.36.433
+- Add monitor related.
+
+2020-05-26 Version: 1.36.432
+- Add monitor related.
+
+2020-05-25 Version: 1.36.431
+- Add monitor related.
+
+2020-05-25 Version: 1.36.430
+- Add monitor related.
+
+2020-05-23 Version: 1.36.429
+- Generated 2015-01-01 for `R-kvstore`.
+- Add ModifyResourceGroup API.
+- DescribeInstanceAttribute return ResourceGroupId.
+
+2020-05-22 Version: 1.36.428
+- Add schedule crud api.
+
+2020-05-21 Version: 1.36.427
+- Support more error Codes.
+
+2020-05-20 Version: 1.36.426
+- Generated 2019-09-10 for `waf-openapi`.
+
 2020-05-20 Version: 1.36.425
 - Edit GetTrace and SearchTraces api.
 

VERSION

@@ -1 +1 @@
-1.36.425
+1.36.441

arms/include/alibabacloud/arms/model/SearchTracesRequest.h

@@ -31,6 +31,11 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_ARMS_EXPORT SearchTracesRequest : public RpcServiceRequest
 			{
 			public:
+				struct ExclusionFilters
+				{
+					std::string value;
+					std::string key;
+				};
 				struct Tag
 				{
 					std::string value;
@@ -51,6 +56,8 @@ namespace AlibabaCloud
 				void setMinDuration(long minDuration);
 				std::string getServiceIp()const;
 				void setServiceIp(const std::string& serviceIp);
+				std::vector<ExclusionFilters> getExclusionFilters()const;
+				void setExclusionFilters(const std::vector<ExclusionFilters>& exclusionFilters);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
 				std::string getOperationName()const;
@@ -66,6 +73,7 @@ namespace AlibabaCloud
 				bool reverse_;
 				long minDuration_;
 				std::string serviceIp_;
+				std::vector<ExclusionFilters> exclusionFilters_;
 				std::string regionId_;
 				std::string operationName_;
 				std::string serviceName_;

arms/src/model/SearchTracesRequest.cc

@@ -82,6 +82,22 @@ void SearchTracesRequest::setServiceIp(const std::string& serviceIp)
 	setParameter("ServiceIp", serviceIp);
 }
 
+std::vector<SearchTracesRequest::ExclusionFilters> SearchTracesRequest::getExclusionFilters()const
+{
+	return exclusionFilters_;
+}
+
+void SearchTracesRequest::setExclusionFilters(const std::vector<ExclusionFilters>& exclusionFilters)
+{
+	exclusionFilters_ = exclusionFilters;
+	for(int dep1 = 0; dep1!= exclusionFilters.size(); dep1++) {
+		auto exclusionFiltersObj = exclusionFilters.at(dep1);
+		std::string exclusionFiltersObjStr = "ExclusionFilters." + std::to_string(dep1 + 1);
+		setParameter(exclusionFiltersObjStr + ".Value", exclusionFiltersObj.value);
+		setParameter(exclusionFiltersObjStr + ".Key", exclusionFiltersObj.key);
+	}
+}
+
 std::string SearchTracesRequest::getRegionId()const
 {
 	return regionId_;

dds/include/alibabacloud/dds/model/DescribeTagsRequest.h

@@ -43,6 +43,8 @@ namespace AlibabaCloud
 				void setRegionId(const std::string& regionId);
 				std::string getNextToken()const;
 				void setNextToken(const std::string& nextToken);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
@@ -51,16 +53,20 @@ namespace AlibabaCloud
 				void setOwnerId(long ownerId);
 				std::string getResourceType()const;
 				void setResourceType(const std::string& resourceType);
+				std::string getCategory()const;
+				void setCategory(const std::string& category);
 
             private:
 				long resourceOwnerId_;
 				std::string accessKeyId_;
 				std::string regionId_;
 				std::string nextToken_;
+				std::string product_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				long ownerId_;
 				std::string resourceType_;
+				std::string category_;
 
 			};
 		}

dds/src/model/DescribeTagsRequest.cc

@@ -71,6 +71,17 @@ void DescribeTagsRequest::setNextToken(const std::string& nextToken)
 	setParameter("NextToken", nextToken);
 }
 
+std::string DescribeTagsRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeTagsRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
 std::string DescribeTagsRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -115,3 +126,14 @@ void DescribeTagsRequest::setResourceType(const std::string& resourceType)
 	setParameter("ResourceType", resourceType);
 }
 
+std::string DescribeTagsRequest::getCategory()const
+{
+	return category_;
+}
+
+void DescribeTagsRequest::setCategory(const std::string& category)
+{
+	category_ = category;
+	setParameter("Category", category);
+}
+

ehpc/include/alibabacloud/ehpc/model/ApplyNodesRequest.h

@@ -68,8 +68,8 @@ namespace AlibabaCloud
 				void setZoneInfos(const std::vector<ZoneInfos>& zoneInfos);
 				std::string getHostNamePrefix()const;
 				void setHostNamePrefix(const std::string& hostNamePrefix);
-				std::string getComputeSpotPriceLimit()const;
-				void setComputeSpotPriceLimit(const std::string& computeSpotPriceLimit);
+				float getComputeSpotPriceLimit()const;
+				void setComputeSpotPriceLimit(float computeSpotPriceLimit);
 				std::string getClusterId()const;
 				void setClusterId(const std::string& clusterId);
 				std::string getComputeSpotStrategy()const;
@@ -80,8 +80,6 @@ namespace AlibabaCloud
 				void setPriorityStrategy(const std::string& priorityStrategy);
 				std::string getInstanceFamilyLevel()const;
 				void setInstanceFamilyLevel(const std::string& instanceFamilyLevel);
-				std::string getEcsChargeType()const;
-				void setEcsChargeType(const std::string& ecsChargeType);
 				std::string getInternetChargeType()const;
 				void setInternetChargeType(const std::string& internetChargeType);
 				std::vector<InstanceTypeModel> getInstanceTypeModel()const;
@@ -105,13 +103,12 @@ namespace AlibabaCloud
 				int systemDiskSize_;
 				std::vector<ZoneInfos> zoneInfos_;
 				std::string hostNamePrefix_;
-				std::string computeSpotPriceLimit_;
+				float computeSpotPriceLimit_;
 				std::string clusterId_;
 				std::string computeSpotStrategy_;
 				std::string hostNameSuffix_;
 				std::string priorityStrategy_;
 				std::string instanceFamilyLevel_;
-				std::string ecsChargeType_;
 				std::string internetChargeType_;
 				std::vector<InstanceTypeModel> instanceTypeModel_;
 				int internetMaxBandWidthIn_;

ehpc/include/alibabacloud/ehpc/model/ApplyNodesResult.h

@@ -37,12 +37,14 @@ namespace AlibabaCloud
 				ApplyNodesResult();
 				explicit ApplyNodesResult(const std::string &payload);
 				~ApplyNodesResult();
+				int getSatisfiedAmount()const;
 				std::vector<std::string> getInstanceIds()const;
 				std::string getDetail()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				int satisfiedAmount_;
 				std::vector<std::string> instanceIds_;
 				std::string detail_;
 

ehpc/src/model/ApplyNodesRequest.cc

@@ -153,15 +153,15 @@ void ApplyNodesRequest::setHostNamePrefix(const std::string& hostNamePrefix)
 	setParameter("HostNamePrefix", hostNamePrefix);
 }
 
-std::string ApplyNodesRequest::getComputeSpotPriceLimit()const
+float ApplyNodesRequest::getComputeSpotPriceLimit()const
 {
 	return computeSpotPriceLimit_;
 }
 
-void ApplyNodesRequest::setComputeSpotPriceLimit(const std::string& computeSpotPriceLimit)
+void ApplyNodesRequest::setComputeSpotPriceLimit(float computeSpotPriceLimit)
 {
 	computeSpotPriceLimit_ = computeSpotPriceLimit;
-	setParameter("ComputeSpotPriceLimit", computeSpotPriceLimit);
+	setParameter("ComputeSpotPriceLimit", std::to_string(computeSpotPriceLimit));
 }
 
 std::string ApplyNodesRequest::getClusterId()const
@@ -219,17 +219,6 @@ void ApplyNodesRequest::setInstanceFamilyLevel(const std::string& instanceFamily
 	setParameter("InstanceFamilyLevel", instanceFamilyLevel);
 }
 
-std::string ApplyNodesRequest::getEcsChargeType()const
-{
-	return ecsChargeType_;
-}
-
-void ApplyNodesRequest::setEcsChargeType(const std::string& ecsChargeType)
-{
-	ecsChargeType_ = ecsChargeType;
-	setParameter("EcsChargeType", ecsChargeType);
-}
-
 std::string ApplyNodesRequest::getInternetChargeType()const
 {
 	return internetChargeType_;

ehpc/src/model/ApplyNodesResult.cc

@@ -44,9 +44,16 @@ void ApplyNodesResult::parse(const std::string &payload)
 		instanceIds_.push_back(item.asString());
 	if(!value["Detail"].isNull())
 		detail_ = value["Detail"].asString();
+	if(!value["SatisfiedAmount"].isNull())
+		satisfiedAmount_ = std::stoi(value["SatisfiedAmount"].asString());
 
 }
 
+int ApplyNodesResult::getSatisfiedAmount()const
+{
+	return satisfiedAmount_;
+}
+
 std::vector<std::string> ApplyNodesResult::getInstanceIds()const
 {
 	return instanceIds_;

et-industry-openapi/CMakeLists.txt

@@ -22,16 +22,12 @@ set(et-industry-openapi_public_header
 
 set(et-industry-openapi_public_header_model 
 	include/alibabacloud/et-industry-openapi/model/UploadDeviceDataRequest.h
-	include/alibabacloud/et-industry-openapi/model/UploadDeviceDataResult.h
-	include/alibabacloud/et-industry-openapi/model/UploadDeviceDataDCRequest.h
-	include/alibabacloud/et-industry-openapi/model/UploadDeviceDataDCResult.h )
+	include/alibabacloud/et-industry-openapi/model/UploadDeviceDataResult.h )
 
 set(et-industry-openapi_src 
 	src/Et-industry-openapiClient.cc
 	src/model/UploadDeviceDataRequest.cc
-	src/model/UploadDeviceDataResult.cc
-	src/model/UploadDeviceDataDCRequest.cc
-	src/model/UploadDeviceDataDCResult.cc )
+	src/model/UploadDeviceDataResult.cc )
 
 add_library(et-industry-openapi ${LIB_TYPE}
 	${et-industry-openapi_public_header}

et-industry-openapi/include/alibabacloud/et-industry-openapi/Et_industry_openapiClient.h

@@ -22,10 +22,8 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RoaServiceClient.h>
 #include "Et_industry_openapiExport.h"
-#include "model/UploadDeviceDataRequest.h"
-#include "model/UploadDeviceDataResult.h"
-#include "model/UploadDeviceDataDCRequest.h"
-#include "model/UploadDeviceDataDCResult.h"
+#include "model/UploadDeviceDataRequest.h"
+#include "model/UploadDeviceDataResult.h"
 
 
 namespace AlibabaCloud
@@ -37,10 +35,7 @@ namespace AlibabaCloud
 		public:
 			typedef Outcome<Error, Model::UploadDeviceDataResult> UploadDeviceDataOutcome;
 			typedef std::future<UploadDeviceDataOutcome> UploadDeviceDataOutcomeCallable;
-			typedef std::function<void(const Et_industry_openapiClient*, const Model::UploadDeviceDataRequest&, const UploadDeviceDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UploadDeviceDataAsyncHandler;
-			typedef Outcome<Error, Model::UploadDeviceDataDCResult> UploadDeviceDataDCOutcome;
-			typedef std::future<UploadDeviceDataDCOutcome> UploadDeviceDataDCOutcomeCallable;
-			typedef std::function<void(const Et_industry_openapiClient*, const Model::UploadDeviceDataDCRequest&, const UploadDeviceDataDCOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UploadDeviceDataDCAsyncHandler;
+			typedef std::function<void(const Et_industry_openapiClient*, const Model::UploadDeviceDataRequest&, const UploadDeviceDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UploadDeviceDataAsyncHandler;
 
 			Et_industry_openapiClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			Et_industry_openapiClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -48,10 +43,7 @@ namespace AlibabaCloud
 			~Et_industry_openapiClient();
 			UploadDeviceDataOutcome uploadDeviceData(const Model::UploadDeviceDataRequest &request)const;
 			void uploadDeviceDataAsync(const Model::UploadDeviceDataRequest& request, const UploadDeviceDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			UploadDeviceDataOutcomeCallable uploadDeviceDataCallable(const Model::UploadDeviceDataRequest& request) const;
-			UploadDeviceDataDCOutcome uploadDeviceDataDC(const Model::UploadDeviceDataDCRequest &request)const;
-			void uploadDeviceDataDCAsync(const Model::UploadDeviceDataDCRequest& request, const UploadDeviceDataDCAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			UploadDeviceDataDCOutcomeCallable uploadDeviceDataDCCallable(const Model::UploadDeviceDataDCRequest& request) const;
+			UploadDeviceDataOutcomeCallable uploadDeviceDataCallable(const Model::UploadDeviceDataRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

et-industry-openapi/include/alibabacloud/et-industry-openapi/model/UploadDeviceDataDCRequest.h

@@ -1,67 +0,0 @@
-/*
- * 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_ET_INDUSTRY_OPENAPI_MODEL_UPLOADDEVICEDATADCREQUEST_H_
-#define ALIBABACLOUD_ET_INDUSTRY_OPENAPI_MODEL_UPLOADDEVICEDATADCREQUEST_H_
-
-#include <string>
-#include <vector>
-#include <alibabacloud/core/RoaServiceRequest.h>
-#include <alibabacloud/et-industry-openapi/Et_industry_openapiExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Et_industry_openapi
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_ET_INDUSTRY_OPENAPI_EXPORT UploadDeviceDataDCRequest : public RoaServiceRequest
-			{
-			public:
-				struct data
-				{
-					struct data
-					{
-						std::string device_id;
-						std::string create_time;
-						std::string system_code;
-						std::string time;
-						std::string systime;
-						std::string value;
-						std::string key;
-					};
-					std::vector<data> data;
-					std::string pk;
-				};
-
-			public:
-				UploadDeviceDataDCRequest();
-				~UploadDeviceDataDCRequest();
-
-				std::vector<data> getData()const;
-				void setData(const std::vector<data>& data);
-				int getTaskId()const;
-				void setTaskId(int taskId);
-
-            private:
-				std::vector<data> data_;
-				int taskId_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_ET_INDUSTRY_OPENAPI_MODEL_UPLOADDEVICEDATADCREQUEST_H_

et-industry-openapi/src/Et-industry-openapiClient.cc

@@ -86,40 +86,3 @@ Et_industry_openapiClient::UploadDeviceDataOutcomeCallable Et_industry_openapiCl
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
-Et_industry_openapiClient::UploadDeviceDataDCOutcome Et_industry_openapiClient::uploadDeviceDataDC(const UploadDeviceDataDCRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return UploadDeviceDataDCOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return UploadDeviceDataDCOutcome(UploadDeviceDataDCResult(outcome.result()));
-	else
-		return UploadDeviceDataDCOutcome(outcome.error());
-}
-
-void Et_industry_openapiClient::uploadDeviceDataDCAsync(const UploadDeviceDataDCRequest& request, const UploadDeviceDataDCAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, uploadDeviceDataDC(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-Et_industry_openapiClient::UploadDeviceDataDCOutcomeCallable Et_industry_openapiClient::uploadDeviceDataDCCallable(const UploadDeviceDataDCRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<UploadDeviceDataDCOutcome()>>(
-			[this, request]()
-			{
-			return this->uploadDeviceDataDC(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-

et-industry-openapi/src/model/UploadDeviceDataDCRequest.cc

@@ -1,67 +0,0 @@
-/*
- * 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/et-industry-openapi/model/UploadDeviceDataDCRequest.h>
-
-using AlibabaCloud::Et_industry_openapi::Model::UploadDeviceDataDCRequest;
-
-UploadDeviceDataDCRequest::UploadDeviceDataDCRequest() :
-	RoaServiceRequest("et-industry-openapi", "2019-06-10")
-{
-	setResourcePath("/api/report/point");
-	setMethod(HttpRequest::Method::Post);
-}
-
-UploadDeviceDataDCRequest::~UploadDeviceDataDCRequest()
-{}
-
-std::vector<UploadDeviceDataDCRequest::data> UploadDeviceDataDCRequest::getData()const
-{
-	return data_;
-}
-
-void UploadDeviceDataDCRequest::setData(const std::vector<data>& data)
-{
-	data_ = data;
-	for(int dep1 = 0; dep1!= data.size(); dep1++) {
-		auto dataObj = data.at(dep1);
-		std::string dataObjStr = "data." + std::to_string(dep1 + 1);
-		for(int dep2 = 0; dep2!= dataObj.data.size(); dep2++) {
-			auto dataObj = dataObj.data.at(dep2);
-			std::string dataObjStr = dataObjStr + "data." + std::to_string(dep2 + 1);
-			setParameter(dataObjStr + ".Device_id", dataObj.device_id);
-			setParameter(dataObjStr + ".Create_time", dataObj.create_time);
-			setParameter(dataObjStr + ".System_code", dataObj.system_code);
-			setParameter(dataObjStr + ".Time", dataObj.time);
-			setParameter(dataObjStr + ".Systime", dataObj.systime);
-			setParameter(dataObjStr + ".Value", dataObj.value);
-			setParameter(dataObjStr + ".Key", dataObj.key);
-		}
-		setParameter(dataObjStr + ".Pk", dataObj.pk);
-	}
-}
-
-int UploadDeviceDataDCRequest::getTaskId()const
-{
-	return taskId_;
-}
-
-void UploadDeviceDataDCRequest::setTaskId(int taskId)
-{
-	taskId_ = taskId;
-	setBodyParameter("TaskId", std::to_string(taskId));
-}
-

fnf/CMakeLists.txt

@@ -23,18 +23,26 @@ set(fnf_public_header
 set(fnf_public_header_model 
 	include/alibabacloud/fnf/model/CreateFlowRequest.h
 	include/alibabacloud/fnf/model/CreateFlowResult.h
+	include/alibabacloud/fnf/model/CreateScheduleRequest.h
+	include/alibabacloud/fnf/model/CreateScheduleResult.h
 	include/alibabacloud/fnf/model/DeleteFlowRequest.h
 	include/alibabacloud/fnf/model/DeleteFlowResult.h
+	include/alibabacloud/fnf/model/DeleteScheduleRequest.h
+	include/alibabacloud/fnf/model/DeleteScheduleResult.h
 	include/alibabacloud/fnf/model/DescribeExecutionRequest.h
 	include/alibabacloud/fnf/model/DescribeExecutionResult.h
 	include/alibabacloud/fnf/model/DescribeFlowRequest.h
 	include/alibabacloud/fnf/model/DescribeFlowResult.h
+	include/alibabacloud/fnf/model/DescribeScheduleRequest.h
+	include/alibabacloud/fnf/model/DescribeScheduleResult.h
 	include/alibabacloud/fnf/model/GetExecutionHistoryRequest.h
 	include/alibabacloud/fnf/model/GetExecutionHistoryResult.h
 	include/alibabacloud/fnf/model/ListExecutionsRequest.h
 	include/alibabacloud/fnf/model/ListExecutionsResult.h
 	include/alibabacloud/fnf/model/ListFlowsRequest.h
 	include/alibabacloud/fnf/model/ListFlowsResult.h
+	include/alibabacloud/fnf/model/ListSchedulesRequest.h
+	include/alibabacloud/fnf/model/ListSchedulesResult.h
 	include/alibabacloud/fnf/model/ReportTaskFailedRequest.h
 	include/alibabacloud/fnf/model/ReportTaskFailedResult.h
 	include/alibabacloud/fnf/model/ReportTaskSucceededRequest.h
@@ -44,24 +52,34 @@ set(fnf_public_header_model
 	include/alibabacloud/fnf/model/StopExecutionRequest.h
 	include/alibabacloud/fnf/model/StopExecutionResult.h
 	include/alibabacloud/fnf/model/UpdateFlowRequest.h
-	include/alibabacloud/fnf/model/UpdateFlowResult.h )
+	include/alibabacloud/fnf/model/UpdateFlowResult.h
+	include/alibabacloud/fnf/model/UpdateScheduleRequest.h
+	include/alibabacloud/fnf/model/UpdateScheduleResult.h )
 
 set(fnf_src 
 	src/FnfClient.cc
 	src/model/CreateFlowRequest.cc
 	src/model/CreateFlowResult.cc
+	src/model/CreateScheduleRequest.cc
+	src/model/CreateScheduleResult.cc
 	src/model/DeleteFlowRequest.cc
 	src/model/DeleteFlowResult.cc
+	src/model/DeleteScheduleRequest.cc
+	src/model/DeleteScheduleResult.cc
 	src/model/DescribeExecutionRequest.cc
 	src/model/DescribeExecutionResult.cc
 	src/model/DescribeFlowRequest.cc
 	src/model/DescribeFlowResult.cc
+	src/model/DescribeScheduleRequest.cc
+	src/model/DescribeScheduleResult.cc
 	src/model/GetExecutionHistoryRequest.cc
 	src/model/GetExecutionHistoryResult.cc
 	src/model/ListExecutionsRequest.cc
 	src/model/ListExecutionsResult.cc
 	src/model/ListFlowsRequest.cc
 	src/model/ListFlowsResult.cc
+	src/model/ListSchedulesRequest.cc
+	src/model/ListSchedulesResult.cc
 	src/model/ReportTaskFailedRequest.cc
 	src/model/ReportTaskFailedResult.cc
 	src/model/ReportTaskSucceededRequest.cc
@@ -71,7 +89,9 @@ set(fnf_src
 	src/model/StopExecutionRequest.cc
 	src/model/StopExecutionResult.cc
 	src/model/UpdateFlowRequest.cc
-	src/model/UpdateFlowResult.cc )
+	src/model/UpdateFlowResult.cc
+	src/model/UpdateScheduleRequest.cc
+	src/model/UpdateScheduleResult.cc )
 
 add_library(fnf ${LIB_TYPE}
 	${fnf_public_header}

fnf/include/alibabacloud/fnf/FnfClient.h

@@ -24,18 +24,26 @@
 #include "FnfExport.h"
 #include "model/CreateFlowRequest.h"
 #include "model/CreateFlowResult.h"
+#include "model/CreateScheduleRequest.h"
+#include "model/CreateScheduleResult.h"
 #include "model/DeleteFlowRequest.h"
 #include "model/DeleteFlowResult.h"
+#include "model/DeleteScheduleRequest.h"
+#include "model/DeleteScheduleResult.h"
 #include "model/DescribeExecutionRequest.h"
 #include "model/DescribeExecutionResult.h"
 #include "model/DescribeFlowRequest.h"
 #include "model/DescribeFlowResult.h"
+#include "model/DescribeScheduleRequest.h"
+#include "model/DescribeScheduleResult.h"
 #include "model/GetExecutionHistoryRequest.h"
 #include "model/GetExecutionHistoryResult.h"
 #include "model/ListExecutionsRequest.h"
 #include "model/ListExecutionsResult.h"
 #include "model/ListFlowsRequest.h"
 #include "model/ListFlowsResult.h"
+#include "model/ListSchedulesRequest.h"
+#include "model/ListSchedulesResult.h"
 #include "model/ReportTaskFailedRequest.h"
 #include "model/ReportTaskFailedResult.h"
 #include "model/ReportTaskSucceededRequest.h"
@@ -46,6 +54,8 @@
 #include "model/StopExecutionResult.h"
 #include "model/UpdateFlowRequest.h"
 #include "model/UpdateFlowResult.h"
+#include "model/UpdateScheduleRequest.h"
+#include "model/UpdateScheduleResult.h"
 
 
 namespace AlibabaCloud
@@ -58,15 +68,24 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateFlowResult> CreateFlowOutcome;
 			typedef std::future<CreateFlowOutcome> CreateFlowOutcomeCallable;
 			typedef std::function<void(const FnfClient*, const Model::CreateFlowRequest&, const CreateFlowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFlowAsyncHandler;
+			typedef Outcome<Error, Model::CreateScheduleResult> CreateScheduleOutcome;
+			typedef std::future<CreateScheduleOutcome> CreateScheduleOutcomeCallable;
+			typedef std::function<void(const FnfClient*, const Model::CreateScheduleRequest&, const CreateScheduleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateScheduleAsyncHandler;
 			typedef Outcome<Error, Model::DeleteFlowResult> DeleteFlowOutcome;
 			typedef std::future<DeleteFlowOutcome> DeleteFlowOutcomeCallable;
 			typedef std::function<void(const FnfClient*, const Model::DeleteFlowRequest&, const DeleteFlowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFlowAsyncHandler;
+			typedef Outcome<Error, Model::DeleteScheduleResult> DeleteScheduleOutcome;
+			typedef std::future<DeleteScheduleOutcome> DeleteScheduleOutcomeCallable;
+			typedef std::function<void(const FnfClient*, const Model::DeleteScheduleRequest&, const DeleteScheduleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteScheduleAsyncHandler;
 			typedef Outcome<Error, Model::DescribeExecutionResult> DescribeExecutionOutcome;
 			typedef std::future<DescribeExecutionOutcome> DescribeExecutionOutcomeCallable;
 			typedef std::function<void(const FnfClient*, const Model::DescribeExecutionRequest&, const DescribeExecutionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeExecutionAsyncHandler;
 			typedef Outcome<Error, Model::DescribeFlowResult> DescribeFlowOutcome;
 			typedef std::future<DescribeFlowOutcome> DescribeFlowOutcomeCallable;
 			typedef std::function<void(const FnfClient*, const Model::DescribeFlowRequest&, const DescribeFlowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeFlowAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScheduleResult> DescribeScheduleOutcome;
+			typedef std::future<DescribeScheduleOutcome> DescribeScheduleOutcomeCallable;
+			typedef std::function<void(const FnfClient*, const Model::DescribeScheduleRequest&, const DescribeScheduleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScheduleAsyncHandler;
 			typedef Outcome<Error, Model::GetExecutionHistoryResult> GetExecutionHistoryOutcome;
 			typedef std::future<GetExecutionHistoryOutcome> GetExecutionHistoryOutcomeCallable;
 			typedef std::function<void(const FnfClient*, const Model::GetExecutionHistoryRequest&, const GetExecutionHistoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetExecutionHistoryAsyncHandler;
@@ -76,6 +95,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListFlowsResult> ListFlowsOutcome;
 			typedef std::future<ListFlowsOutcome> ListFlowsOutcomeCallable;
 			typedef std::function<void(const FnfClient*, const Model::ListFlowsRequest&, const ListFlowsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFlowsAsyncHandler;
+			typedef Outcome<Error, Model::ListSchedulesResult> ListSchedulesOutcome;
+			typedef std::future<ListSchedulesOutcome> ListSchedulesOutcomeCallable;
+			typedef std::function<void(const FnfClient*, const Model::ListSchedulesRequest&, const ListSchedulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSchedulesAsyncHandler;
 			typedef Outcome<Error, Model::ReportTaskFailedResult> ReportTaskFailedOutcome;
 			typedef std::future<ReportTaskFailedOutcome> ReportTaskFailedOutcomeCallable;
 			typedef std::function<void(const FnfClient*, const Model::ReportTaskFailedRequest&, const ReportTaskFailedOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReportTaskFailedAsyncHandler;
@@ -91,6 +113,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateFlowResult> UpdateFlowOutcome;
 			typedef std::future<UpdateFlowOutcome> UpdateFlowOutcomeCallable;
 			typedef std::function<void(const FnfClient*, const Model::UpdateFlowRequest&, const UpdateFlowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateFlowAsyncHandler;
+			typedef Outcome<Error, Model::UpdateScheduleResult> UpdateScheduleOutcome;
+			typedef std::future<UpdateScheduleOutcome> UpdateScheduleOutcomeCallable;
+			typedef std::function<void(const FnfClient*, const Model::UpdateScheduleRequest&, const UpdateScheduleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateScheduleAsyncHandler;
 
 			FnfClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			FnfClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -99,15 +124,24 @@ namespace AlibabaCloud
 			CreateFlowOutcome createFlow(const Model::CreateFlowRequest &request)const;
 			void createFlowAsync(const Model::CreateFlowRequest& request, const CreateFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateFlowOutcomeCallable createFlowCallable(const Model::CreateFlowRequest& request) const;
+			CreateScheduleOutcome createSchedule(const Model::CreateScheduleRequest &request)const;
+			void createScheduleAsync(const Model::CreateScheduleRequest& request, const CreateScheduleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateScheduleOutcomeCallable createScheduleCallable(const Model::CreateScheduleRequest& request) const;
 			DeleteFlowOutcome deleteFlow(const Model::DeleteFlowRequest &request)const;
 			void deleteFlowAsync(const Model::DeleteFlowRequest& request, const DeleteFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteFlowOutcomeCallable deleteFlowCallable(const Model::DeleteFlowRequest& request) const;
+			DeleteScheduleOutcome deleteSchedule(const Model::DeleteScheduleRequest &request)const;
+			void deleteScheduleAsync(const Model::DeleteScheduleRequest& request, const DeleteScheduleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteScheduleOutcomeCallable deleteScheduleCallable(const Model::DeleteScheduleRequest& request) const;
 			DescribeExecutionOutcome describeExecution(const Model::DescribeExecutionRequest &request)const;
 			void describeExecutionAsync(const Model::DescribeExecutionRequest& request, const DescribeExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeExecutionOutcomeCallable describeExecutionCallable(const Model::DescribeExecutionRequest& request) const;
 			DescribeFlowOutcome describeFlow(const Model::DescribeFlowRequest &request)const;
 			void describeFlowAsync(const Model::DescribeFlowRequest& request, const DescribeFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeFlowOutcomeCallable describeFlowCallable(const Model::DescribeFlowRequest& request) const;
+			DescribeScheduleOutcome describeSchedule(const Model::DescribeScheduleRequest &request)const;
+			void describeScheduleAsync(const Model::DescribeScheduleRequest& request, const DescribeScheduleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScheduleOutcomeCallable describeScheduleCallable(const Model::DescribeScheduleRequest& request) const;
 			GetExecutionHistoryOutcome getExecutionHistory(const Model::GetExecutionHistoryRequest &request)const;
 			void getExecutionHistoryAsync(const Model::GetExecutionHistoryRequest& request, const GetExecutionHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetExecutionHistoryOutcomeCallable getExecutionHistoryCallable(const Model::GetExecutionHistoryRequest& request) const;
@@ -117,6 +151,9 @@ namespace AlibabaCloud
 			ListFlowsOutcome listFlows(const Model::ListFlowsRequest &request)const;
 			void listFlowsAsync(const Model::ListFlowsRequest& request, const ListFlowsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListFlowsOutcomeCallable listFlowsCallable(const Model::ListFlowsRequest& request) const;
+			ListSchedulesOutcome listSchedules(const Model::ListSchedulesRequest &request)const;
+			void listSchedulesAsync(const Model::ListSchedulesRequest& request, const ListSchedulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSchedulesOutcomeCallable listSchedulesCallable(const Model::ListSchedulesRequest& request) const;
 			ReportTaskFailedOutcome reportTaskFailed(const Model::ReportTaskFailedRequest &request)const;
 			void reportTaskFailedAsync(const Model::ReportTaskFailedRequest& request, const ReportTaskFailedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ReportTaskFailedOutcomeCallable reportTaskFailedCallable(const Model::ReportTaskFailedRequest& request) const;
@@ -132,6 +169,9 @@ namespace AlibabaCloud
 			UpdateFlowOutcome updateFlow(const Model::UpdateFlowRequest &request)const;
 			void updateFlowAsync(const Model::UpdateFlowRequest& request, const UpdateFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateFlowOutcomeCallable updateFlowCallable(const Model::UpdateFlowRequest& request) const;
+			UpdateScheduleOutcome updateSchedule(const Model::UpdateScheduleRequest &request)const;
+			void updateScheduleAsync(const Model::UpdateScheduleRequest& request, const UpdateScheduleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateScheduleOutcomeCallable updateScheduleCallable(const Model::UpdateScheduleRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

fnf/include/alibabacloud/fnf/model/CreateScheduleRequest.h

@@ -0,0 +1,66 @@
+/*
+ * 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_FNF_MODEL_CREATESCHEDULEREQUEST_H_
+#define ALIBABACLOUD_FNF_MODEL_CREATESCHEDULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/fnf/FnfExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Fnf
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FNF_EXPORT CreateScheduleRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateScheduleRequest();
+				~CreateScheduleRequest();
+
+				std::string getScheduleName()const;
+				void setScheduleName(const std::string& scheduleName);
+				std::string getCronExpression()const;
+				void setCronExpression(const std::string& cronExpression);
+				std::string getPayload()const;
+				void setPayload(const std::string& payload);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+				bool getEnable()const;
+				void setEnable(bool enable);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getFlowName()const;
+				void setFlowName(const std::string& flowName);
+
+            private:
+				std::string scheduleName_;
+				std::string cronExpression_;
+				std::string payload_;
+				std::string requestId_;
+				bool enable_;
+				std::string description_;
+				std::string flowName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FNF_MODEL_CREATESCHEDULEREQUEST_H_

fnf/include/alibabacloud/fnf/model/CreateScheduleResult.h

@@ -0,0 +1,65 @@
+/*
+ * 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_FNF_MODEL_CREATESCHEDULERESULT_H_
+#define ALIBABACLOUD_FNF_MODEL_CREATESCHEDULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/fnf/FnfExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Fnf
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FNF_EXPORT CreateScheduleResult : public ServiceResult
+			{
+			public:
+
+
+				CreateScheduleResult();
+				explicit CreateScheduleResult(const std::string &payload);
+				~CreateScheduleResult();
+				std::string getDescription()const;
+				std::string getCreatedTime()const;
+				std::string getLastModifiedTime()const;
+				bool getEnable()const;
+				std::string getPayload()const;
+				std::string getCronExpression()const;
+				std::string getScheduleId()const;
+				std::string getScheduleName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string description_;
+				std::string createdTime_;
+				std::string lastModifiedTime_;
+				bool enable_;
+				std::string payload_;
+				std::string cronExpression_;
+				std::string scheduleId_;
+				std::string scheduleName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FNF_MODEL_CREATESCHEDULERESULT_H_

fnf/include/alibabacloud/fnf/model/DeleteScheduleRequest.h

@@ -0,0 +1,54 @@
+/*
+ * 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_FNF_MODEL_DELETESCHEDULEREQUEST_H_
+#define ALIBABACLOUD_FNF_MODEL_DELETESCHEDULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/fnf/FnfExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Fnf
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FNF_EXPORT DeleteScheduleRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteScheduleRequest();
+				~DeleteScheduleRequest();
+
+				std::string getScheduleName()const;
+				void setScheduleName(const std::string& scheduleName);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+				std::string getFlowName()const;
+				void setFlowName(const std::string& flowName);
+
+            private:
+				std::string scheduleName_;
+				std::string requestId_;
+				std::string flowName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FNF_MODEL_DELETESCHEDULEREQUEST_H_

fnf/include/alibabacloud/fnf/model/DeleteScheduleResult.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_FNF_MODEL_DELETESCHEDULERESULT_H_
+#define ALIBABACLOUD_FNF_MODEL_DELETESCHEDULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/fnf/FnfExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Fnf
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FNF_EXPORT DeleteScheduleResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteScheduleResult();
+				explicit DeleteScheduleResult(const std::string &payload);
+				~DeleteScheduleResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FNF_MODEL_DELETESCHEDULERESULT_H_

fnf/include/alibabacloud/fnf/model/DescribeScheduleRequest.h

@@ -0,0 +1,54 @@
+/*
+ * 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_FNF_MODEL_DESCRIBESCHEDULEREQUEST_H_
+#define ALIBABACLOUD_FNF_MODEL_DESCRIBESCHEDULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/fnf/FnfExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Fnf
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FNF_EXPORT DescribeScheduleRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeScheduleRequest();
+				~DescribeScheduleRequest();
+
+				std::string getScheduleName()const;
+				void setScheduleName(const std::string& scheduleName);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+				std::string getFlowName()const;
+				void setFlowName(const std::string& flowName);
+
+            private:
+				std::string scheduleName_;
+				std::string requestId_;
+				std::string flowName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FNF_MODEL_DESCRIBESCHEDULEREQUEST_H_

fnf/include/alibabacloud/fnf/model/DescribeScheduleResult.h

@@ -0,0 +1,65 @@
+/*
+ * 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_FNF_MODEL_DESCRIBESCHEDULERESULT_H_
+#define ALIBABACLOUD_FNF_MODEL_DESCRIBESCHEDULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/fnf/FnfExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Fnf
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FNF_EXPORT DescribeScheduleResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeScheduleResult();
+				explicit DescribeScheduleResult(const std::string &payload);
+				~DescribeScheduleResult();
+				std::string getDescription()const;
+				std::string getCreatedTime()const;
+				std::string getLastModifiedTime()const;
+				bool getEnable()const;
+				std::string getPayload()const;
+				std::string getCronExpression()const;
+				std::string getScheduleId()const;
+				std::string getScheduleName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string description_;
+				std::string createdTime_;
+				std::string lastModifiedTime_;
+				bool enable_;
+				std::string payload_;
+				std::string cronExpression_;
+				std::string scheduleId_;
+				std::string scheduleName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FNF_MODEL_DESCRIBESCHEDULERESULT_H_

fnf/include/alibabacloud/fnf/model/ListSchedulesRequest.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_FNF_MODEL_LISTSCHEDULESREQUEST_H_
+#define ALIBABACLOUD_FNF_MODEL_LISTSCHEDULESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/fnf/FnfExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Fnf
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FNF_EXPORT ListSchedulesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListSchedulesRequest();
+				~ListSchedulesRequest();
+
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+				int getLimit()const;
+				void setLimit(int limit);
+				std::string getFlowName()const;
+				void setFlowName(const std::string& flowName);
+
+            private:
+				std::string nextToken_;
+				std::string requestId_;
+				int limit_;
+				std::string flowName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FNF_MODEL_LISTSCHEDULESREQUEST_H_

fnf/include/alibabacloud/fnf/model/ListSchedulesResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_FNF_MODEL_LISTSCHEDULESRESULT_H_
+#define ALIBABACLOUD_FNF_MODEL_LISTSCHEDULESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/fnf/FnfExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Fnf
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FNF_EXPORT ListSchedulesResult : public ServiceResult
+			{
+			public:
+				struct SchedulesItem
+				{
+					std::string description;
+					std::string createdTime;
+					std::string lastModifiedTime;
+					bool enable;
+					std::string payload;
+					std::string cronExpression;
+					std::string scheduleId;
+					std::string scheduleName;
+				};
+
+
+				ListSchedulesResult();
+				explicit ListSchedulesResult(const std::string &payload);
+				~ListSchedulesResult();
+				std::vector<SchedulesItem> getSchedules()const;
+				std::string getNextToken()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<SchedulesItem> schedules_;
+				std::string nextToken_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FNF_MODEL_LISTSCHEDULESRESULT_H_

fnf/include/alibabacloud/fnf/model/UpdateScheduleRequest.h

@@ -0,0 +1,66 @@
+/*
+ * 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_FNF_MODEL_UPDATESCHEDULEREQUEST_H_
+#define ALIBABACLOUD_FNF_MODEL_UPDATESCHEDULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/fnf/FnfExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Fnf
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FNF_EXPORT UpdateScheduleRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateScheduleRequest();
+				~UpdateScheduleRequest();
+
+				std::string getScheduleName()const;
+				void setScheduleName(const std::string& scheduleName);
+				std::string getCronExpression()const;
+				void setCronExpression(const std::string& cronExpression);
+				std::string getPayload()const;
+				void setPayload(const std::string& payload);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+				bool getEnable()const;
+				void setEnable(bool enable);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getFlowName()const;
+				void setFlowName(const std::string& flowName);
+
+            private:
+				std::string scheduleName_;
+				std::string cronExpression_;
+				std::string payload_;
+				std::string requestId_;
+				bool enable_;
+				std::string description_;
+				std::string flowName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FNF_MODEL_UPDATESCHEDULEREQUEST_H_

fnf/include/alibabacloud/fnf/model/UpdateScheduleResult.h

@@ -0,0 +1,65 @@
+/*
+ * 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_FNF_MODEL_UPDATESCHEDULERESULT_H_
+#define ALIBABACLOUD_FNF_MODEL_UPDATESCHEDULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/fnf/FnfExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Fnf
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FNF_EXPORT UpdateScheduleResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateScheduleResult();
+				explicit UpdateScheduleResult(const std::string &payload);
+				~UpdateScheduleResult();
+				std::string getDescription()const;
+				std::string getCreatedTime()const;
+				std::string getLastModifiedTime()const;
+				bool getEnable()const;
+				std::string getPayload()const;
+				std::string getCronExpression()const;
+				std::string getScheduleId()const;
+				std::string getScheduleName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string description_;
+				std::string createdTime_;
+				std::string lastModifiedTime_;
+				bool enable_;
+				std::string payload_;
+				std::string cronExpression_;
+				std::string scheduleId_;
+				std::string scheduleName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FNF_MODEL_UPDATESCHEDULERESULT_H_

fnf/src/FnfClient.cc

@@ -31,21 +31,21 @@ FnfClient::FnfClient(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, "fnf");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 FnfClient::FnfClient(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, "fnf");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 FnfClient::FnfClient(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, "fnf");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 FnfClient::~FnfClient()
@@ -87,6 +87,42 @@ FnfClient::CreateFlowOutcomeCallable FnfClient::createFlowCallable(const CreateF
 	return task->get_future();
 }
 
+FnfClient::CreateScheduleOutcome FnfClient::createSchedule(const CreateScheduleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateScheduleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateScheduleOutcome(CreateScheduleResult(outcome.result()));
+	else
+		return CreateScheduleOutcome(outcome.error());
+}
+
+void FnfClient::createScheduleAsync(const CreateScheduleRequest& request, const CreateScheduleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createSchedule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FnfClient::CreateScheduleOutcomeCallable FnfClient::createScheduleCallable(const CreateScheduleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateScheduleOutcome()>>(
+			[this, request]()
+			{
+			return this->createSchedule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 FnfClient::DeleteFlowOutcome FnfClient::deleteFlow(const DeleteFlowRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -123,6 +159,42 @@ FnfClient::DeleteFlowOutcomeCallable FnfClient::deleteFlowCallable(const DeleteF
 	return task->get_future();
 }
 
+FnfClient::DeleteScheduleOutcome FnfClient::deleteSchedule(const DeleteScheduleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteScheduleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteScheduleOutcome(DeleteScheduleResult(outcome.result()));
+	else
+		return DeleteScheduleOutcome(outcome.error());
+}
+
+void FnfClient::deleteScheduleAsync(const DeleteScheduleRequest& request, const DeleteScheduleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteSchedule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FnfClient::DeleteScheduleOutcomeCallable FnfClient::deleteScheduleCallable(const DeleteScheduleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteScheduleOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteSchedule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 FnfClient::DescribeExecutionOutcome FnfClient::describeExecution(const DescribeExecutionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -195,6 +267,42 @@ FnfClient::DescribeFlowOutcomeCallable FnfClient::describeFlowCallable(const Des
 	return task->get_future();
 }
 
+FnfClient::DescribeScheduleOutcome FnfClient::describeSchedule(const DescribeScheduleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScheduleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScheduleOutcome(DescribeScheduleResult(outcome.result()));
+	else
+		return DescribeScheduleOutcome(outcome.error());
+}
+
+void FnfClient::describeScheduleAsync(const DescribeScheduleRequest& request, const DescribeScheduleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeSchedule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FnfClient::DescribeScheduleOutcomeCallable FnfClient::describeScheduleCallable(const DescribeScheduleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScheduleOutcome()>>(
+			[this, request]()
+			{
+			return this->describeSchedule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 FnfClient::GetExecutionHistoryOutcome FnfClient::getExecutionHistory(const GetExecutionHistoryRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -303,6 +411,42 @@ FnfClient::ListFlowsOutcomeCallable FnfClient::listFlowsCallable(const ListFlows
 	return task->get_future();
 }
 
+FnfClient::ListSchedulesOutcome FnfClient::listSchedules(const ListSchedulesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListSchedulesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListSchedulesOutcome(ListSchedulesResult(outcome.result()));
+	else
+		return ListSchedulesOutcome(outcome.error());
+}
+
+void FnfClient::listSchedulesAsync(const ListSchedulesRequest& request, const ListSchedulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listSchedules(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FnfClient::ListSchedulesOutcomeCallable FnfClient::listSchedulesCallable(const ListSchedulesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListSchedulesOutcome()>>(
+			[this, request]()
+			{
+			return this->listSchedules(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 FnfClient::ReportTaskFailedOutcome FnfClient::reportTaskFailed(const ReportTaskFailedRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -483,3 +627,39 @@ FnfClient::UpdateFlowOutcomeCallable FnfClient::updateFlowCallable(const UpdateF
 	return task->get_future();
 }
 
+FnfClient::UpdateScheduleOutcome FnfClient::updateSchedule(const UpdateScheduleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateScheduleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateScheduleOutcome(UpdateScheduleResult(outcome.result()));
+	else
+		return UpdateScheduleOutcome(outcome.error());
+}
+
+void FnfClient::updateScheduleAsync(const UpdateScheduleRequest& request, const UpdateScheduleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateSchedule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FnfClient::UpdateScheduleOutcomeCallable FnfClient::updateScheduleCallable(const UpdateScheduleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateScheduleOutcome()>>(
+			[this, request]()
+			{
+			return this->updateSchedule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

fnf/src/model/CreateScheduleRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * 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/fnf/model/CreateScheduleRequest.h>
+
+using AlibabaCloud::Fnf::Model::CreateScheduleRequest;
+
+CreateScheduleRequest::CreateScheduleRequest() :
+	RpcServiceRequest("fnf", "2019-03-15", "CreateSchedule")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateScheduleRequest::~CreateScheduleRequest()
+{}
+
+std::string CreateScheduleRequest::getScheduleName()const
+{
+	return scheduleName_;
+}
+
+void CreateScheduleRequest::setScheduleName(const std::string& scheduleName)
+{
+	scheduleName_ = scheduleName;
+	setBodyParameter("ScheduleName", scheduleName);
+}
+
+std::string CreateScheduleRequest::getCronExpression()const
+{
+	return cronExpression_;
+}
+
+void CreateScheduleRequest::setCronExpression(const std::string& cronExpression)
+{
+	cronExpression_ = cronExpression;
+	setBodyParameter("CronExpression", cronExpression);
+}
+
+std::string CreateScheduleRequest::getPayload()const
+{
+	return payload_;
+}
+
+void CreateScheduleRequest::setPayload(const std::string& payload)
+{
+	payload_ = payload;
+	setBodyParameter("Payload", payload);
+}
+
+std::string CreateScheduleRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void CreateScheduleRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+bool CreateScheduleRequest::getEnable()const
+{
+	return enable_;
+}
+
+void CreateScheduleRequest::setEnable(bool enable)
+{
+	enable_ = enable;
+	setBodyParameter("Enable", enable ? "true" : "false");
+}
+
+std::string CreateScheduleRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateScheduleRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setBodyParameter("Description", description);
+}
+
+std::string CreateScheduleRequest::getFlowName()const
+{
+	return flowName_;
+}
+
+void CreateScheduleRequest::setFlowName(const std::string& flowName)
+{
+	flowName_ = flowName;
+	setBodyParameter("FlowName", flowName);
+}
+

fnf/src/model/CreateScheduleResult.cc

@@ -0,0 +1,100 @@
+/*
+ * 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/fnf/model/CreateScheduleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Fnf;
+using namespace AlibabaCloud::Fnf::Model;
+
+CreateScheduleResult::CreateScheduleResult() :
+	ServiceResult()
+{}
+
+CreateScheduleResult::CreateScheduleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateScheduleResult::~CreateScheduleResult()
+{}
+
+void CreateScheduleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ScheduleName"].isNull())
+		scheduleName_ = value["ScheduleName"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["ScheduleId"].isNull())
+		scheduleId_ = value["ScheduleId"].asString();
+	if(!value["Payload"].isNull())
+		payload_ = value["Payload"].asString();
+	if(!value["CronExpression"].isNull())
+		cronExpression_ = value["CronExpression"].asString();
+	if(!value["Enable"].isNull())
+		enable_ = value["Enable"].asString() == "true";
+	if(!value["CreatedTime"].isNull())
+		createdTime_ = value["CreatedTime"].asString();
+	if(!value["LastModifiedTime"].isNull())
+		lastModifiedTime_ = value["LastModifiedTime"].asString();
+
+}
+
+std::string CreateScheduleResult::getDescription()const
+{
+	return description_;
+}
+
+std::string CreateScheduleResult::getCreatedTime()const
+{
+	return createdTime_;
+}
+
+std::string CreateScheduleResult::getLastModifiedTime()const
+{
+	return lastModifiedTime_;
+}
+
+bool CreateScheduleResult::getEnable()const
+{
+	return enable_;
+}
+
+std::string CreateScheduleResult::getPayload()const
+{
+	return payload_;
+}
+
+std::string CreateScheduleResult::getCronExpression()const
+{
+	return cronExpression_;
+}
+
+std::string CreateScheduleResult::getScheduleId()const
+{
+	return scheduleId_;
+}
+
+std::string CreateScheduleResult::getScheduleName()const
+{
+	return scheduleName_;
+}
+

fnf/src/model/DeleteScheduleRequest.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/fnf/model/DeleteScheduleRequest.h>
+
+using AlibabaCloud::Fnf::Model::DeleteScheduleRequest;
+
+DeleteScheduleRequest::DeleteScheduleRequest() :
+	RpcServiceRequest("fnf", "2019-03-15", "DeleteSchedule")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+DeleteScheduleRequest::~DeleteScheduleRequest()
+{}
+
+std::string DeleteScheduleRequest::getScheduleName()const
+{
+	return scheduleName_;
+}
+
+void DeleteScheduleRequest::setScheduleName(const std::string& scheduleName)
+{
+	scheduleName_ = scheduleName;
+	setParameter("ScheduleName", scheduleName);
+}
+
+std::string DeleteScheduleRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DeleteScheduleRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DeleteScheduleRequest::getFlowName()const
+{
+	return flowName_;
+}
+
+void DeleteScheduleRequest::setFlowName(const std::string& flowName)
+{
+	flowName_ = flowName;
+	setParameter("FlowName", flowName);
+}
+

fnf/src/model/DeleteScheduleResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/fnf/model/DeleteScheduleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Fnf;
+using namespace AlibabaCloud::Fnf::Model;
+
+DeleteScheduleResult::DeleteScheduleResult() :
+	ServiceResult()
+{}
+
+DeleteScheduleResult::DeleteScheduleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteScheduleResult::~DeleteScheduleResult()
+{}
+
+void DeleteScheduleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

fnf/src/model/DescribeScheduleRequest.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/fnf/model/DescribeScheduleRequest.h>
+
+using AlibabaCloud::Fnf::Model::DescribeScheduleRequest;
+
+DescribeScheduleRequest::DescribeScheduleRequest() :
+	RpcServiceRequest("fnf", "2019-03-15", "DescribeSchedule")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeScheduleRequest::~DescribeScheduleRequest()
+{}
+
+std::string DescribeScheduleRequest::getScheduleName()const
+{
+	return scheduleName_;
+}
+
+void DescribeScheduleRequest::setScheduleName(const std::string& scheduleName)
+{
+	scheduleName_ = scheduleName;
+	setParameter("ScheduleName", scheduleName);
+}
+
+std::string DescribeScheduleRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScheduleRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeScheduleRequest::getFlowName()const
+{
+	return flowName_;
+}
+
+void DescribeScheduleRequest::setFlowName(const std::string& flowName)
+{
+	flowName_ = flowName;
+	setParameter("FlowName", flowName);
+}
+

fnf/src/model/DescribeScheduleResult.cc

@@ -0,0 +1,100 @@
+/*
+ * 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/fnf/model/DescribeScheduleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Fnf;
+using namespace AlibabaCloud::Fnf::Model;
+
+DescribeScheduleResult::DescribeScheduleResult() :
+	ServiceResult()
+{}
+
+DescribeScheduleResult::DescribeScheduleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScheduleResult::~DescribeScheduleResult()
+{}
+
+void DescribeScheduleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ScheduleName"].isNull())
+		scheduleName_ = value["ScheduleName"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["ScheduleId"].isNull())
+		scheduleId_ = value["ScheduleId"].asString();
+	if(!value["Payload"].isNull())
+		payload_ = value["Payload"].asString();
+	if(!value["CronExpression"].isNull())
+		cronExpression_ = value["CronExpression"].asString();
+	if(!value["Enable"].isNull())
+		enable_ = value["Enable"].asString() == "true";
+	if(!value["CreatedTime"].isNull())
+		createdTime_ = value["CreatedTime"].asString();
+	if(!value["LastModifiedTime"].isNull())
+		lastModifiedTime_ = value["LastModifiedTime"].asString();
+
+}
+
+std::string DescribeScheduleResult::getDescription()const
+{
+	return description_;
+}
+
+std::string DescribeScheduleResult::getCreatedTime()const
+{
+	return createdTime_;
+}
+
+std::string DescribeScheduleResult::getLastModifiedTime()const
+{
+	return lastModifiedTime_;
+}
+
+bool DescribeScheduleResult::getEnable()const
+{
+	return enable_;
+}
+
+std::string DescribeScheduleResult::getPayload()const
+{
+	return payload_;
+}
+
+std::string DescribeScheduleResult::getCronExpression()const
+{
+	return cronExpression_;
+}
+
+std::string DescribeScheduleResult::getScheduleId()const
+{
+	return scheduleId_;
+}
+
+std::string DescribeScheduleResult::getScheduleName()const
+{
+	return scheduleName_;
+}
+

fnf/src/model/ListSchedulesRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * 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/fnf/model/ListSchedulesRequest.h>
+
+using AlibabaCloud::Fnf::Model::ListSchedulesRequest;
+
+ListSchedulesRequest::ListSchedulesRequest() :
+	RpcServiceRequest("fnf", "2019-03-15", "ListSchedules")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+ListSchedulesRequest::~ListSchedulesRequest()
+{}
+
+std::string ListSchedulesRequest::getNextToken()const
+{
+	return nextToken_;
+}
+
+void ListSchedulesRequest::setNextToken(const std::string& nextToken)
+{
+	nextToken_ = nextToken;
+	setParameter("NextToken", nextToken);
+}
+
+std::string ListSchedulesRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void ListSchedulesRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+int ListSchedulesRequest::getLimit()const
+{
+	return limit_;
+}
+
+void ListSchedulesRequest::setLimit(int limit)
+{
+	limit_ = limit;
+	setParameter("Limit", std::to_string(limit));
+}
+
+std::string ListSchedulesRequest::getFlowName()const
+{
+	return flowName_;
+}
+
+void ListSchedulesRequest::setFlowName(const std::string& flowName)
+{
+	flowName_ = flowName;
+	setParameter("FlowName", flowName);
+}
+

fnf/src/model/ListSchedulesResult.cc

@@ -0,0 +1,78 @@
+/*
+ * 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/fnf/model/ListSchedulesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Fnf;
+using namespace AlibabaCloud::Fnf::Model;
+
+ListSchedulesResult::ListSchedulesResult() :
+	ServiceResult()
+{}
+
+ListSchedulesResult::ListSchedulesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListSchedulesResult::~ListSchedulesResult()
+{}
+
+void ListSchedulesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allSchedulesNode = value["Schedules"]["SchedulesItem"];
+	for (auto valueSchedulesSchedulesItem : allSchedulesNode)
+	{
+		SchedulesItem schedulesObject;
+		if(!valueSchedulesSchedulesItem["ScheduleName"].isNull())
+			schedulesObject.scheduleName = valueSchedulesSchedulesItem["ScheduleName"].asString();
+		if(!valueSchedulesSchedulesItem["Description"].isNull())
+			schedulesObject.description = valueSchedulesSchedulesItem["Description"].asString();
+		if(!valueSchedulesSchedulesItem["ScheduleId"].isNull())
+			schedulesObject.scheduleId = valueSchedulesSchedulesItem["ScheduleId"].asString();
+		if(!valueSchedulesSchedulesItem["Payload"].isNull())
+			schedulesObject.payload = valueSchedulesSchedulesItem["Payload"].asString();
+		if(!valueSchedulesSchedulesItem["CronExpression"].isNull())
+			schedulesObject.cronExpression = valueSchedulesSchedulesItem["CronExpression"].asString();
+		if(!valueSchedulesSchedulesItem["Enable"].isNull())
+			schedulesObject.enable = valueSchedulesSchedulesItem["Enable"].asString() == "true";
+		if(!valueSchedulesSchedulesItem["CreatedTime"].isNull())
+			schedulesObject.createdTime = valueSchedulesSchedulesItem["CreatedTime"].asString();
+		if(!valueSchedulesSchedulesItem["LastModifiedTime"].isNull())
+			schedulesObject.lastModifiedTime = valueSchedulesSchedulesItem["LastModifiedTime"].asString();
+		schedules_.push_back(schedulesObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+
+}
+
+std::vector<ListSchedulesResult::SchedulesItem> ListSchedulesResult::getSchedules()const
+{
+	return schedules_;
+}
+
+std::string ListSchedulesResult::getNextToken()const
+{
+	return nextToken_;
+}
+

fnf/src/model/UpdateScheduleRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * 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/fnf/model/UpdateScheduleRequest.h>
+
+using AlibabaCloud::Fnf::Model::UpdateScheduleRequest;
+
+UpdateScheduleRequest::UpdateScheduleRequest() :
+	RpcServiceRequest("fnf", "2019-03-15", "UpdateSchedule")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UpdateScheduleRequest::~UpdateScheduleRequest()
+{}
+
+std::string UpdateScheduleRequest::getScheduleName()const
+{
+	return scheduleName_;
+}
+
+void UpdateScheduleRequest::setScheduleName(const std::string& scheduleName)
+{
+	scheduleName_ = scheduleName;
+	setBodyParameter("ScheduleName", scheduleName);
+}
+
+std::string UpdateScheduleRequest::getCronExpression()const
+{
+	return cronExpression_;
+}
+
+void UpdateScheduleRequest::setCronExpression(const std::string& cronExpression)
+{
+	cronExpression_ = cronExpression;
+	setBodyParameter("CronExpression", cronExpression);
+}
+
+std::string UpdateScheduleRequest::getPayload()const
+{
+	return payload_;
+}
+
+void UpdateScheduleRequest::setPayload(const std::string& payload)
+{
+	payload_ = payload;
+	setBodyParameter("Payload", payload);
+}
+
+std::string UpdateScheduleRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void UpdateScheduleRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+bool UpdateScheduleRequest::getEnable()const
+{
+	return enable_;
+}
+
+void UpdateScheduleRequest::setEnable(bool enable)
+{
+	enable_ = enable;
+	setBodyParameter("Enable", enable ? "true" : "false");
+}
+
+std::string UpdateScheduleRequest::getDescription()const
+{
+	return description_;
+}
+
+void UpdateScheduleRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setBodyParameter("Description", description);
+}
+
+std::string UpdateScheduleRequest::getFlowName()const
+{
+	return flowName_;
+}
+
+void UpdateScheduleRequest::setFlowName(const std::string& flowName)
+{
+	flowName_ = flowName;
+	setBodyParameter("FlowName", flowName);
+}
+

fnf/src/model/UpdateScheduleResult.cc

@@ -0,0 +1,100 @@
+/*
+ * 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/fnf/model/UpdateScheduleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Fnf;
+using namespace AlibabaCloud::Fnf::Model;
+
+UpdateScheduleResult::UpdateScheduleResult() :
+	ServiceResult()
+{}
+
+UpdateScheduleResult::UpdateScheduleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateScheduleResult::~UpdateScheduleResult()
+{}
+
+void UpdateScheduleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ScheduleName"].isNull())
+		scheduleName_ = value["ScheduleName"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["ScheduleId"].isNull())
+		scheduleId_ = value["ScheduleId"].asString();
+	if(!value["Payload"].isNull())
+		payload_ = value["Payload"].asString();
+	if(!value["CronExpression"].isNull())
+		cronExpression_ = value["CronExpression"].asString();
+	if(!value["Enable"].isNull())
+		enable_ = value["Enable"].asString() == "true";
+	if(!value["CreatedTime"].isNull())
+		createdTime_ = value["CreatedTime"].asString();
+	if(!value["LastModifiedTime"].isNull())
+		lastModifiedTime_ = value["LastModifiedTime"].asString();
+
+}
+
+std::string UpdateScheduleResult::getDescription()const
+{
+	return description_;
+}
+
+std::string UpdateScheduleResult::getCreatedTime()const
+{
+	return createdTime_;
+}
+
+std::string UpdateScheduleResult::getLastModifiedTime()const
+{
+	return lastModifiedTime_;
+}
+
+bool UpdateScheduleResult::getEnable()const
+{
+	return enable_;
+}
+
+std::string UpdateScheduleResult::getPayload()const
+{
+	return payload_;
+}
+
+std::string UpdateScheduleResult::getCronExpression()const
+{
+	return cronExpression_;
+}
+
+std::string UpdateScheduleResult::getScheduleId()const
+{
+	return scheduleId_;
+}
+
+std::string UpdateScheduleResult::getScheduleName()const
+{
+	return scheduleName_;
+}
+

hbase/CMakeLists.txt

@@ -31,12 +31,16 @@ set(hbase_public_header_model
 	include/alibabacloud/hbase/model/CreateClusterResult.h
 	include/alibabacloud/hbase/model/CreateHbaseHaSlbRequest.h
 	include/alibabacloud/hbase/model/CreateHbaseHaSlbResult.h
+	include/alibabacloud/hbase/model/CreateMultiZoneClusterRequest.h
+	include/alibabacloud/hbase/model/CreateMultiZoneClusterResult.h
 	include/alibabacloud/hbase/model/CreateRestorePlanRequest.h
 	include/alibabacloud/hbase/model/CreateRestorePlanResult.h
 	include/alibabacloud/hbase/model/DeleteHbaseHaSlbRequest.h
 	include/alibabacloud/hbase/model/DeleteHbaseHaSlbResult.h
 	include/alibabacloud/hbase/model/DeleteInstanceRequest.h
 	include/alibabacloud/hbase/model/DeleteInstanceResult.h
+	include/alibabacloud/hbase/model/DeleteMultiZoneClusterRequest.h
+	include/alibabacloud/hbase/model/DeleteMultiZoneClusterResult.h
 	include/alibabacloud/hbase/model/DeleteUserHdfsInfoRequest.h
 	include/alibabacloud/hbase/model/DeleteUserHdfsInfoResult.h
 	include/alibabacloud/hbase/model/DescribeAvailableResourceRequest.h
@@ -130,12 +134,16 @@ set(hbase_src
 	src/model/CreateClusterResult.cc
 	src/model/CreateHbaseHaSlbRequest.cc
 	src/model/CreateHbaseHaSlbResult.cc
+	src/model/CreateMultiZoneClusterRequest.cc
+	src/model/CreateMultiZoneClusterResult.cc
 	src/model/CreateRestorePlanRequest.cc
 	src/model/CreateRestorePlanResult.cc
 	src/model/DeleteHbaseHaSlbRequest.cc
 	src/model/DeleteHbaseHaSlbResult.cc
 	src/model/DeleteInstanceRequest.cc
 	src/model/DeleteInstanceResult.cc
+	src/model/DeleteMultiZoneClusterRequest.cc
+	src/model/DeleteMultiZoneClusterResult.cc
 	src/model/DeleteUserHdfsInfoRequest.cc
 	src/model/DeleteUserHdfsInfoResult.cc
 	src/model/DescribeAvailableResourceRequest.cc

hbase/include/alibabacloud/hbase/HBaseClient.h

@@ -32,12 +32,16 @@
 #include "model/CreateClusterResult.h"
 #include "model/CreateHbaseHaSlbRequest.h"
 #include "model/CreateHbaseHaSlbResult.h"
+#include "model/CreateMultiZoneClusterRequest.h"
+#include "model/CreateMultiZoneClusterResult.h"
 #include "model/CreateRestorePlanRequest.h"
 #include "model/CreateRestorePlanResult.h"
 #include "model/DeleteHbaseHaSlbRequest.h"
 #include "model/DeleteHbaseHaSlbResult.h"
 #include "model/DeleteInstanceRequest.h"
 #include "model/DeleteInstanceResult.h"
+#include "model/DeleteMultiZoneClusterRequest.h"
+#include "model/DeleteMultiZoneClusterResult.h"
 #include "model/DeleteUserHdfsInfoRequest.h"
 #include "model/DeleteUserHdfsInfoResult.h"
 #include "model/DescribeAvailableResourceRequest.h"
@@ -142,6 +146,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateHbaseHaSlbResult> CreateHbaseHaSlbOutcome;
 			typedef std::future<CreateHbaseHaSlbOutcome> CreateHbaseHaSlbOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::CreateHbaseHaSlbRequest&, const CreateHbaseHaSlbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateHbaseHaSlbAsyncHandler;
+			typedef Outcome<Error, Model::CreateMultiZoneClusterResult> CreateMultiZoneClusterOutcome;
+			typedef std::future<CreateMultiZoneClusterOutcome> CreateMultiZoneClusterOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::CreateMultiZoneClusterRequest&, const CreateMultiZoneClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMultiZoneClusterAsyncHandler;
 			typedef Outcome<Error, Model::CreateRestorePlanResult> CreateRestorePlanOutcome;
 			typedef std::future<CreateRestorePlanOutcome> CreateRestorePlanOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::CreateRestorePlanRequest&, const CreateRestorePlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRestorePlanAsyncHandler;
@@ -151,6 +158,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteInstanceResult> DeleteInstanceOutcome;
 			typedef std::future<DeleteInstanceOutcome> DeleteInstanceOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::DeleteInstanceRequest&, const DeleteInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteInstanceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteMultiZoneClusterResult> DeleteMultiZoneClusterOutcome;
+			typedef std::future<DeleteMultiZoneClusterOutcome> DeleteMultiZoneClusterOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DeleteMultiZoneClusterRequest&, const DeleteMultiZoneClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteMultiZoneClusterAsyncHandler;
 			typedef Outcome<Error, Model::DeleteUserHdfsInfoResult> DeleteUserHdfsInfoOutcome;
 			typedef std::future<DeleteUserHdfsInfoOutcome> DeleteUserHdfsInfoOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::DeleteUserHdfsInfoRequest&, const DeleteUserHdfsInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteUserHdfsInfoAsyncHandler;
@@ -291,6 +301,9 @@ namespace AlibabaCloud
 			CreateHbaseHaSlbOutcome createHbaseHaSlb(const Model::CreateHbaseHaSlbRequest &request)const;
 			void createHbaseHaSlbAsync(const Model::CreateHbaseHaSlbRequest& request, const CreateHbaseHaSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateHbaseHaSlbOutcomeCallable createHbaseHaSlbCallable(const Model::CreateHbaseHaSlbRequest& request) const;
+			CreateMultiZoneClusterOutcome createMultiZoneCluster(const Model::CreateMultiZoneClusterRequest &request)const;
+			void createMultiZoneClusterAsync(const Model::CreateMultiZoneClusterRequest& request, const CreateMultiZoneClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateMultiZoneClusterOutcomeCallable createMultiZoneClusterCallable(const Model::CreateMultiZoneClusterRequest& request) const;
 			CreateRestorePlanOutcome createRestorePlan(const Model::CreateRestorePlanRequest &request)const;
 			void createRestorePlanAsync(const Model::CreateRestorePlanRequest& request, const CreateRestorePlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateRestorePlanOutcomeCallable createRestorePlanCallable(const Model::CreateRestorePlanRequest& request) const;
@@ -300,6 +313,9 @@ namespace AlibabaCloud
 			DeleteInstanceOutcome deleteInstance(const Model::DeleteInstanceRequest &request)const;
 			void deleteInstanceAsync(const Model::DeleteInstanceRequest& request, const DeleteInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteInstanceOutcomeCallable deleteInstanceCallable(const Model::DeleteInstanceRequest& request) const;
+			DeleteMultiZoneClusterOutcome deleteMultiZoneCluster(const Model::DeleteMultiZoneClusterRequest &request)const;
+			void deleteMultiZoneClusterAsync(const Model::DeleteMultiZoneClusterRequest& request, const DeleteMultiZoneClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteMultiZoneClusterOutcomeCallable deleteMultiZoneClusterCallable(const Model::DeleteMultiZoneClusterRequest& request) const;
 			DeleteUserHdfsInfoOutcome deleteUserHdfsInfo(const Model::DeleteUserHdfsInfoRequest &request)const;
 			void deleteUserHdfsInfoAsync(const Model::DeleteUserHdfsInfoRequest& request, const DeleteUserHdfsInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteUserHdfsInfoOutcomeCallable deleteUserHdfsInfoCallable(const Model::DeleteUserHdfsInfoRequest& request) const;

hbase/include/alibabacloud/hbase/model/CreateMultiZoneClusterRequest.h

@@ -0,0 +1,129 @@
+/*
+ * 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_HBASE_MODEL_CREATEMULTIZONECLUSTERREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_CREATEMULTIZONECLUSTERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT CreateMultiZoneClusterRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateMultiZoneClusterRequest();
+				~CreateMultiZoneClusterRequest();
+
+				std::string getArchVersion()const;
+				void setArchVersion(const std::string& archVersion);
+				std::string getClusterName()const;
+				void setClusterName(const std::string& clusterName);
+				std::string getEngineVersion()const;
+				void setEngineVersion(const std::string& engineVersion);
+				std::string getLogDiskType()const;
+				void setLogDiskType(const std::string& logDiskType);
+				std::string getPrimaryVSwitchId()const;
+				void setPrimaryVSwitchId(const std::string& primaryVSwitchId);
+				std::string getLogInstanceType()const;
+				void setLogInstanceType(const std::string& logInstanceType);
+				int getAutoRenewPeriod()const;
+				void setAutoRenewPeriod(int autoRenewPeriod);
+				int getPeriod()const;
+				void setPeriod(int period);
+				int getLogNodeCount()const;
+				void setLogNodeCount(int logNodeCount);
+				std::string getSecurityIPList()const;
+				void setSecurityIPList(const std::string& securityIPList);
+				std::string getPeriodUnit()const;
+				void setPeriodUnit(const std::string& periodUnit);
+				std::string getCoreDiskType()const;
+				void setCoreDiskType(const std::string& coreDiskType);
+				std::string getArbiterZoneId()const;
+				void setArbiterZoneId(const std::string& arbiterZoneId);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getMultiZoneCombination()const;
+				void setMultiZoneCombination(const std::string& multiZoneCombination);
+				std::string getPrimaryZoneId()const;
+				void setPrimaryZoneId(const std::string& primaryZoneId);
+				std::string getEngine()const;
+				void setEngine(const std::string& engine);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getStandbyVSwitchId()const;
+				void setStandbyVSwitchId(const std::string& standbyVSwitchId);
+				std::string getStandbyZoneId()const;
+				void setStandbyZoneId(const std::string& standbyZoneId);
+				std::string getMasterInstanceType()const;
+				void setMasterInstanceType(const std::string& masterInstanceType);
+				int getCoreNodeCount()const;
+				void setCoreNodeCount(int coreNodeCount);
+				int getLogDiskSize()const;
+				void setLogDiskSize(int logDiskSize);
+				std::string getCoreInstanceType()const;
+				void setCoreInstanceType(const std::string& coreInstanceType);
+				int getCoreDiskSize()const;
+				void setCoreDiskSize(int coreDiskSize);
+				std::string getVpcId()const;
+				void setVpcId(const std::string& vpcId);
+				std::string getPayType()const;
+				void setPayType(const std::string& payType);
+				std::string getArbiterVSwitchId()const;
+				void setArbiterVSwitchId(const std::string& arbiterVSwitchId);
+
+            private:
+				std::string archVersion_;
+				std::string clusterName_;
+				std::string engineVersion_;
+				std::string logDiskType_;
+				std::string primaryVSwitchId_;
+				std::string logInstanceType_;
+				int autoRenewPeriod_;
+				int period_;
+				int logNodeCount_;
+				std::string securityIPList_;
+				std::string periodUnit_;
+				std::string coreDiskType_;
+				std::string arbiterZoneId_;
+				std::string clientToken_;
+				std::string multiZoneCombination_;
+				std::string primaryZoneId_;
+				std::string engine_;
+				std::string regionId_;
+				std::string standbyVSwitchId_;
+				std::string standbyZoneId_;
+				std::string masterInstanceType_;
+				int coreNodeCount_;
+				int logDiskSize_;
+				std::string coreInstanceType_;
+				int coreDiskSize_;
+				std::string vpcId_;
+				std::string payType_;
+				std::string arbiterVSwitchId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_CREATEMULTIZONECLUSTERREQUEST_H_

hbase/include/alibabacloud/hbase/model/CreateMultiZoneClusterResult.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_HBASE_MODEL_CREATEMULTIZONECLUSTERRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_CREATEMULTIZONECLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT CreateMultiZoneClusterResult : public ServiceResult
+			{
+			public:
+
+
+				CreateMultiZoneClusterResult();
+				explicit CreateMultiZoneClusterResult(const std::string &payload);
+				~CreateMultiZoneClusterResult();
+				std::string getClusterId()const;
+				std::string getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string clusterId_;
+				std::string orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_CREATEMULTIZONECLUSTERRESULT_H_

hbase/include/alibabacloud/hbase/model/DeleteMultiZoneClusterRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_DELETEMULTIZONECLUSTERREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DELETEMULTIZONECLUSTERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DeleteMultiZoneClusterRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteMultiZoneClusterRequest();
+				~DeleteMultiZoneClusterRequest();
+
+				bool getImmediateDeleteFlag()const;
+				void setImmediateDeleteFlag(bool immediateDeleteFlag);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+
+            private:
+				bool immediateDeleteFlag_;
+				std::string clusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEMULTIZONECLUSTERREQUEST_H_

hbase/include/alibabacloud/hbase/model/DeleteMultiZoneClusterResult.h

@@ -14,29 +14,29 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SAS_MODEL_MODIFYDELETEVULWHITELISTRESULT_H_
-#define ALIBABACLOUD_SAS_MODEL_MODIFYDELETEVULWHITELISTRESULT_H_
+#ifndef ALIBABACLOUD_HBASE_MODEL_DELETEMULTIZONECLUSTERRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DELETEMULTIZONECLUSTERRESULT_H_
 
 #include <string>
 #include <vector>
 #include <utility>
 #include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/sas/SasExport.h>
+#include <alibabacloud/hbase/HBaseExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Sas
+	namespace HBase
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SAS_EXPORT ModifyDeleteVulWhitelistResult : public ServiceResult
+			class ALIBABACLOUD_HBASE_EXPORT DeleteMultiZoneClusterResult : public ServiceResult
 			{
 			public:
 
 
-				ModifyDeleteVulWhitelistResult();
-				explicit ModifyDeleteVulWhitelistResult(const std::string &payload);
-				~ModifyDeleteVulWhitelistResult();
+				DeleteMultiZoneClusterResult();
+				explicit DeleteMultiZoneClusterResult(const std::string &payload);
+				~DeleteMultiZoneClusterResult();
 
 			protected:
 				void parse(const std::string &payload);
@@ -46,4 +46,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SAS_MODEL_MODIFYDELETEVULWHITELISTRESULT_H_
+#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEMULTIZONECLUSTERRESULT_H_

hbase/include/alibabacloud/hbase/model/DescribeAvailableResourceResult.h

@@ -58,6 +58,7 @@ namespace AlibabaCloud
 										InstanceTypeDetail instanceTypeDetail;
 										DBInstanceStorageRange dBInstanceStorageRange;
 										std::string instanceType;
+										int maxCoreCount;
 									};
 									std::string storageType;
 									std::vector<SupportedStorageType::CoreResource> coreResources;

hbase/include/alibabacloud/hbase/model/DescribeInstancesResult.h

@@ -54,6 +54,7 @@ namespace AlibabaCloud
 					std::string status;
 					std::string majorVersion;
 					std::string parentId;
+					std::string coreDiskCount;
 					int masterDiskSize;
 					std::string expireTimeUTC;
 					std::string zoneId;

hbase/src/HBaseClient.cc

@@ -231,6 +231,42 @@ HBaseClient::CreateHbaseHaSlbOutcomeCallable HBaseClient::createHbaseHaSlbCallab
 	return task->get_future();
 }
 
+HBaseClient::CreateMultiZoneClusterOutcome HBaseClient::createMultiZoneCluster(const CreateMultiZoneClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateMultiZoneClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateMultiZoneClusterOutcome(CreateMultiZoneClusterResult(outcome.result()));
+	else
+		return CreateMultiZoneClusterOutcome(outcome.error());
+}
+
+void HBaseClient::createMultiZoneClusterAsync(const CreateMultiZoneClusterRequest& request, const CreateMultiZoneClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createMultiZoneCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::CreateMultiZoneClusterOutcomeCallable HBaseClient::createMultiZoneClusterCallable(const CreateMultiZoneClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateMultiZoneClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->createMultiZoneCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::CreateRestorePlanOutcome HBaseClient::createRestorePlan(const CreateRestorePlanRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -339,6 +375,42 @@ HBaseClient::DeleteInstanceOutcomeCallable HBaseClient::deleteInstanceCallable(c
 	return task->get_future();
 }
 
+HBaseClient::DeleteMultiZoneClusterOutcome HBaseClient::deleteMultiZoneCluster(const DeleteMultiZoneClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteMultiZoneClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteMultiZoneClusterOutcome(DeleteMultiZoneClusterResult(outcome.result()));
+	else
+		return DeleteMultiZoneClusterOutcome(outcome.error());
+}
+
+void HBaseClient::deleteMultiZoneClusterAsync(const DeleteMultiZoneClusterRequest& request, const DeleteMultiZoneClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteMultiZoneCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DeleteMultiZoneClusterOutcomeCallable HBaseClient::deleteMultiZoneClusterCallable(const DeleteMultiZoneClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteMultiZoneClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteMultiZoneCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::DeleteUserHdfsInfoOutcome HBaseClient::deleteUserHdfsInfo(const DeleteUserHdfsInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

hbase/src/model/CreateMultiZoneClusterRequest.cc

@@ -0,0 +1,337 @@
+/*
+ * 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/hbase/model/CreateMultiZoneClusterRequest.h>
+
+using AlibabaCloud::HBase::Model::CreateMultiZoneClusterRequest;
+
+CreateMultiZoneClusterRequest::CreateMultiZoneClusterRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "CreateMultiZoneCluster")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateMultiZoneClusterRequest::~CreateMultiZoneClusterRequest()
+{}
+
+std::string CreateMultiZoneClusterRequest::getArchVersion()const
+{
+	return archVersion_;
+}
+
+void CreateMultiZoneClusterRequest::setArchVersion(const std::string& archVersion)
+{
+	archVersion_ = archVersion;
+	setParameter("ArchVersion", archVersion);
+}
+
+std::string CreateMultiZoneClusterRequest::getClusterName()const
+{
+	return clusterName_;
+}
+
+void CreateMultiZoneClusterRequest::setClusterName(const std::string& clusterName)
+{
+	clusterName_ = clusterName;
+	setParameter("ClusterName", clusterName);
+}
+
+std::string CreateMultiZoneClusterRequest::getEngineVersion()const
+{
+	return engineVersion_;
+}
+
+void CreateMultiZoneClusterRequest::setEngineVersion(const std::string& engineVersion)
+{
+	engineVersion_ = engineVersion;
+	setParameter("EngineVersion", engineVersion);
+}
+
+std::string CreateMultiZoneClusterRequest::getLogDiskType()const
+{
+	return logDiskType_;
+}
+
+void CreateMultiZoneClusterRequest::setLogDiskType(const std::string& logDiskType)
+{
+	logDiskType_ = logDiskType;
+	setParameter("LogDiskType", logDiskType);
+}
+
+std::string CreateMultiZoneClusterRequest::getPrimaryVSwitchId()const
+{
+	return primaryVSwitchId_;
+}
+
+void CreateMultiZoneClusterRequest::setPrimaryVSwitchId(const std::string& primaryVSwitchId)
+{
+	primaryVSwitchId_ = primaryVSwitchId;
+	setParameter("PrimaryVSwitchId", primaryVSwitchId);
+}
+
+std::string CreateMultiZoneClusterRequest::getLogInstanceType()const
+{
+	return logInstanceType_;
+}
+
+void CreateMultiZoneClusterRequest::setLogInstanceType(const std::string& logInstanceType)
+{
+	logInstanceType_ = logInstanceType;
+	setParameter("LogInstanceType", logInstanceType);
+}
+
+int CreateMultiZoneClusterRequest::getAutoRenewPeriod()const
+{
+	return autoRenewPeriod_;
+}
+
+void CreateMultiZoneClusterRequest::setAutoRenewPeriod(int autoRenewPeriod)
+{
+	autoRenewPeriod_ = autoRenewPeriod;
+	setParameter("AutoRenewPeriod", std::to_string(autoRenewPeriod));
+}
+
+int CreateMultiZoneClusterRequest::getPeriod()const
+{
+	return period_;
+}
+
+void CreateMultiZoneClusterRequest::setPeriod(int period)
+{
+	period_ = period;
+	setParameter("Period", std::to_string(period));
+}
+
+int CreateMultiZoneClusterRequest::getLogNodeCount()const
+{
+	return logNodeCount_;
+}
+
+void CreateMultiZoneClusterRequest::setLogNodeCount(int logNodeCount)
+{
+	logNodeCount_ = logNodeCount;
+	setParameter("LogNodeCount", std::to_string(logNodeCount));
+}
+
+std::string CreateMultiZoneClusterRequest::getSecurityIPList()const
+{
+	return securityIPList_;
+}
+
+void CreateMultiZoneClusterRequest::setSecurityIPList(const std::string& securityIPList)
+{
+	securityIPList_ = securityIPList;
+	setParameter("SecurityIPList", securityIPList);
+}
+
+std::string CreateMultiZoneClusterRequest::getPeriodUnit()const
+{
+	return periodUnit_;
+}
+
+void CreateMultiZoneClusterRequest::setPeriodUnit(const std::string& periodUnit)
+{
+	periodUnit_ = periodUnit;
+	setParameter("PeriodUnit", periodUnit);
+}
+
+std::string CreateMultiZoneClusterRequest::getCoreDiskType()const
+{
+	return coreDiskType_;
+}
+
+void CreateMultiZoneClusterRequest::setCoreDiskType(const std::string& coreDiskType)
+{
+	coreDiskType_ = coreDiskType;
+	setParameter("CoreDiskType", coreDiskType);
+}
+
+std::string CreateMultiZoneClusterRequest::getArbiterZoneId()const
+{
+	return arbiterZoneId_;
+}
+
+void CreateMultiZoneClusterRequest::setArbiterZoneId(const std::string& arbiterZoneId)
+{
+	arbiterZoneId_ = arbiterZoneId;
+	setParameter("ArbiterZoneId", arbiterZoneId);
+}
+
+std::string CreateMultiZoneClusterRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateMultiZoneClusterRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string CreateMultiZoneClusterRequest::getMultiZoneCombination()const
+{
+	return multiZoneCombination_;
+}
+
+void CreateMultiZoneClusterRequest::setMultiZoneCombination(const std::string& multiZoneCombination)
+{
+	multiZoneCombination_ = multiZoneCombination;
+	setParameter("MultiZoneCombination", multiZoneCombination);
+}
+
+std::string CreateMultiZoneClusterRequest::getPrimaryZoneId()const
+{
+	return primaryZoneId_;
+}
+
+void CreateMultiZoneClusterRequest::setPrimaryZoneId(const std::string& primaryZoneId)
+{
+	primaryZoneId_ = primaryZoneId;
+	setParameter("PrimaryZoneId", primaryZoneId);
+}
+
+std::string CreateMultiZoneClusterRequest::getEngine()const
+{
+	return engine_;
+}
+
+void CreateMultiZoneClusterRequest::setEngine(const std::string& engine)
+{
+	engine_ = engine;
+	setParameter("Engine", engine);
+}
+
+std::string CreateMultiZoneClusterRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateMultiZoneClusterRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateMultiZoneClusterRequest::getStandbyVSwitchId()const
+{
+	return standbyVSwitchId_;
+}
+
+void CreateMultiZoneClusterRequest::setStandbyVSwitchId(const std::string& standbyVSwitchId)
+{
+	standbyVSwitchId_ = standbyVSwitchId;
+	setParameter("StandbyVSwitchId", standbyVSwitchId);
+}
+
+std::string CreateMultiZoneClusterRequest::getStandbyZoneId()const
+{
+	return standbyZoneId_;
+}
+
+void CreateMultiZoneClusterRequest::setStandbyZoneId(const std::string& standbyZoneId)
+{
+	standbyZoneId_ = standbyZoneId;
+	setParameter("StandbyZoneId", standbyZoneId);
+}
+
+std::string CreateMultiZoneClusterRequest::getMasterInstanceType()const
+{
+	return masterInstanceType_;
+}
+
+void CreateMultiZoneClusterRequest::setMasterInstanceType(const std::string& masterInstanceType)
+{
+	masterInstanceType_ = masterInstanceType;
+	setParameter("MasterInstanceType", masterInstanceType);
+}
+
+int CreateMultiZoneClusterRequest::getCoreNodeCount()const
+{
+	return coreNodeCount_;
+}
+
+void CreateMultiZoneClusterRequest::setCoreNodeCount(int coreNodeCount)
+{
+	coreNodeCount_ = coreNodeCount;
+	setParameter("CoreNodeCount", std::to_string(coreNodeCount));
+}
+
+int CreateMultiZoneClusterRequest::getLogDiskSize()const
+{
+	return logDiskSize_;
+}
+
+void CreateMultiZoneClusterRequest::setLogDiskSize(int logDiskSize)
+{
+	logDiskSize_ = logDiskSize;
+	setParameter("LogDiskSize", std::to_string(logDiskSize));
+}
+
+std::string CreateMultiZoneClusterRequest::getCoreInstanceType()const
+{
+	return coreInstanceType_;
+}
+
+void CreateMultiZoneClusterRequest::setCoreInstanceType(const std::string& coreInstanceType)
+{
+	coreInstanceType_ = coreInstanceType;
+	setParameter("CoreInstanceType", coreInstanceType);
+}
+
+int CreateMultiZoneClusterRequest::getCoreDiskSize()const
+{
+	return coreDiskSize_;
+}
+
+void CreateMultiZoneClusterRequest::setCoreDiskSize(int coreDiskSize)
+{
+	coreDiskSize_ = coreDiskSize;
+	setParameter("CoreDiskSize", std::to_string(coreDiskSize));
+}
+
+std::string CreateMultiZoneClusterRequest::getVpcId()const
+{
+	return vpcId_;
+}
+
+void CreateMultiZoneClusterRequest::setVpcId(const std::string& vpcId)
+{
+	vpcId_ = vpcId;
+	setParameter("VpcId", vpcId);
+}
+
+std::string CreateMultiZoneClusterRequest::getPayType()const
+{
+	return payType_;
+}
+
+void CreateMultiZoneClusterRequest::setPayType(const std::string& payType)
+{
+	payType_ = payType;
+	setParameter("PayType", payType);
+}
+
+std::string CreateMultiZoneClusterRequest::getArbiterVSwitchId()const
+{
+	return arbiterVSwitchId_;
+}
+
+void CreateMultiZoneClusterRequest::setArbiterVSwitchId(const std::string& arbiterVSwitchId)
+{
+	arbiterVSwitchId_ = arbiterVSwitchId;
+	setParameter("ArbiterVSwitchId", arbiterVSwitchId);
+}
+

hbase/src/model/CreateMultiZoneClusterResult.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/hbase/model/CreateMultiZoneClusterResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+CreateMultiZoneClusterResult::CreateMultiZoneClusterResult() :
+	ServiceResult()
+{}
+
+CreateMultiZoneClusterResult::CreateMultiZoneClusterResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateMultiZoneClusterResult::~CreateMultiZoneClusterResult()
+{}
+
+void CreateMultiZoneClusterResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ClusterId"].isNull())
+		clusterId_ = value["ClusterId"].asString();
+	if(!value["OrderId"].isNull())
+		orderId_ = value["OrderId"].asString();
+
+}
+
+std::string CreateMultiZoneClusterResult::getClusterId()const
+{
+	return clusterId_;
+}
+
+std::string CreateMultiZoneClusterResult::getOrderId()const
+{
+	return orderId_;
+}
+

hbase/src/model/DeleteMultiZoneClusterRequest.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/hbase/model/DeleteMultiZoneClusterRequest.h>
+
+using AlibabaCloud::HBase::Model::DeleteMultiZoneClusterRequest;
+
+DeleteMultiZoneClusterRequest::DeleteMultiZoneClusterRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DeleteMultiZoneCluster")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteMultiZoneClusterRequest::~DeleteMultiZoneClusterRequest()
+{}
+
+bool DeleteMultiZoneClusterRequest::getImmediateDeleteFlag()const
+{
+	return immediateDeleteFlag_;
+}
+
+void DeleteMultiZoneClusterRequest::setImmediateDeleteFlag(bool immediateDeleteFlag)
+{
+	immediateDeleteFlag_ = immediateDeleteFlag;
+	setParameter("ImmediateDeleteFlag", immediateDeleteFlag ? "true" : "false");
+}
+
+std::string DeleteMultiZoneClusterRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DeleteMultiZoneClusterRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+

hbase/src/model/DeleteMultiZoneClusterResult.cc

@@ -14,34 +14,30 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/sas/model/ModifyDeleteVulWhitelistResult.h>
+#include <alibabacloud/hbase/model/DeleteMultiZoneClusterResult.h>
 #include <json/json.h>
 
-using namespace AlibabaCloud::Sas;
-using namespace AlibabaCloud::Sas::Model;
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
 
-ModifyDeleteVulWhitelistResult::ModifyDeleteVulWhitelistResult() :
+DeleteMultiZoneClusterResult::DeleteMultiZoneClusterResult() :
 	ServiceResult()
 {}
 
-ModifyDeleteVulWhitelistResult::ModifyDeleteVulWhitelistResult(const std::string &payload) :
+DeleteMultiZoneClusterResult::DeleteMultiZoneClusterResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-ModifyDeleteVulWhitelistResult::~ModifyDeleteVulWhitelistResult()
+DeleteMultiZoneClusterResult::~DeleteMultiZoneClusterResult()
 {}
 
-void ModifyDeleteVulWhitelistResult::parse(const std::string &payload)
+void DeleteMultiZoneClusterResult::parse(const std::string &payload)
 {
-	Json::CharReaderBuilder builder;
-	Json::CharReader *reader = builder.newCharReader();
-	Json::Value *val;
+	Json::Reader reader;
 	Json::Value value;
-	JSONCPP_STRING *errs;
-	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
-	value = *val;
+	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 
 }

hbase/src/model/DescribeAvailableResourceResult.cc

@@ -77,6 +77,8 @@ void DescribeAvailableResourceResult::parse(const std::string &payload)
 							AvailableZone::SupportedEngine::SupportedEngineVersion::SupportedCategoriesItem::SupportedStorageType::CoreResource coreResourcesObject;
 							if(!allSupportedStorageTypesNodeCoreResourcesCoreResource["InstanceType"].isNull())
 								coreResourcesObject.instanceType = allSupportedStorageTypesNodeCoreResourcesCoreResource["InstanceType"].asString();
+							if(!allSupportedStorageTypesNodeCoreResourcesCoreResource["MaxCoreCount"].isNull())
+								coreResourcesObject.maxCoreCount = std::stoi(allSupportedStorageTypesNodeCoreResourcesCoreResource["MaxCoreCount"].asString());
 							auto dBInstanceStorageRangeNode = value["DBInstanceStorageRange"];
 							if(!dBInstanceStorageRangeNode["MaxSize"].isNull())
 								coreResourcesObject.dBInstanceStorageRange.maxSize = std::stoi(dBInstanceStorageRangeNode["MaxSize"].asString());

hbase/src/model/DescribeInstancesResult.cc

@@ -109,6 +109,8 @@ void DescribeInstancesResult::parse(const std::string &payload)
 			instancesObject.moduleId = std::stoi(valueInstancesInstance["ModuleId"].asString());
 		if(!valueInstancesInstance["ModuleStackVersion"].isNull())
 			instancesObject.moduleStackVersion = valueInstancesInstance["ModuleStackVersion"].asString();
+		if(!valueInstancesInstance["CoreDiskCount"].isNull())
+			instancesObject.coreDiskCount = valueInstancesInstance["CoreDiskCount"].asString();
 		auto allTagsNode = allInstancesNode["Tags"]["Tag"];
 		for (auto allInstancesNodeTagsTag : allTagsNode)
 		{

nlp-automl/CMakeLists.txt

@@ -30,7 +30,9 @@ set(nlp-automl_public_header_model
 	include/alibabacloud/nlp-automl/model/RunContactReviewRequest.h
 	include/alibabacloud/nlp-automl/model/RunContactReviewResult.h
 	include/alibabacloud/nlp-automl/model/RunPreTrainServiceRequest.h
-	include/alibabacloud/nlp-automl/model/RunPreTrainServiceResult.h )
+	include/alibabacloud/nlp-automl/model/RunPreTrainServiceResult.h
+	include/alibabacloud/nlp-automl/model/RunSmartCallServiceRequest.h
+	include/alibabacloud/nlp-automl/model/RunSmartCallServiceResult.h )
 
 set(nlp-automl_src 
 	src/Nlp-automlClient.cc
@@ -43,7 +45,9 @@ set(nlp-automl_src
 	src/model/RunContactReviewRequest.cc
 	src/model/RunContactReviewResult.cc
 	src/model/RunPreTrainServiceRequest.cc
-	src/model/RunPreTrainServiceResult.cc )
+	src/model/RunPreTrainServiceResult.cc
+	src/model/RunSmartCallServiceRequest.cc
+	src/model/RunSmartCallServiceResult.cc )
 
 add_library(nlp-automl ${LIB_TYPE}
 	${nlp-automl_public_header}

nlp-automl/include/alibabacloud/nlp-automl/Nlp_automlClient.h

@@ -32,6 +32,8 @@
 #include "model/RunContactReviewResult.h"
 #include "model/RunPreTrainServiceRequest.h"
 #include "model/RunPreTrainServiceResult.h"
+#include "model/RunSmartCallServiceRequest.h"
+#include "model/RunSmartCallServiceResult.h"
 
 
 namespace AlibabaCloud
@@ -56,6 +58,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RunPreTrainServiceResult> RunPreTrainServiceOutcome;
 			typedef std::future<RunPreTrainServiceOutcome> RunPreTrainServiceOutcomeCallable;
 			typedef std::function<void(const Nlp_automlClient*, const Model::RunPreTrainServiceRequest&, const RunPreTrainServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RunPreTrainServiceAsyncHandler;
+			typedef Outcome<Error, Model::RunSmartCallServiceResult> RunSmartCallServiceOutcome;
+			typedef std::future<RunSmartCallServiceOutcome> RunSmartCallServiceOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::RunSmartCallServiceRequest&, const RunSmartCallServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RunSmartCallServiceAsyncHandler;
 
 			Nlp_automlClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			Nlp_automlClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -76,6 +81,9 @@ namespace AlibabaCloud
 			RunPreTrainServiceOutcome runPreTrainService(const Model::RunPreTrainServiceRequest &request)const;
 			void runPreTrainServiceAsync(const Model::RunPreTrainServiceRequest& request, const RunPreTrainServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RunPreTrainServiceOutcomeCallable runPreTrainServiceCallable(const Model::RunPreTrainServiceRequest& request) const;
+			RunSmartCallServiceOutcome runSmartCallService(const Model::RunSmartCallServiceRequest &request)const;
+			void runSmartCallServiceAsync(const Model::RunSmartCallServiceRequest& request, const RunSmartCallServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RunSmartCallServiceOutcomeCallable runSmartCallServiceCallable(const Model::RunSmartCallServiceRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

nlp-automl/include/alibabacloud/nlp-automl/model/RunSmartCallServiceRequest.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_NLP_AUTOML_MODEL_RUNSMARTCALLSERVICEREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_RUNSMARTCALLSERVICEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT RunSmartCallServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				RunSmartCallServiceRequest();
+				~RunSmartCallServiceRequest();
+
+				std::string getSessionId()const;
+				void setSessionId(const std::string& sessionId);
+				long getRobotId()const;
+				void setRobotId(long robotId);
+				std::string getParamContent()const;
+				void setParamContent(const std::string& paramContent);
+				std::string getServiceName()const;
+				void setServiceName(const std::string& serviceName);
+
+            private:
+				std::string sessionId_;
+				long robotId_;
+				std::string paramContent_;
+				std::string serviceName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_RUNSMARTCALLSERVICEREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/RunSmartCallServiceResult.h

@@ -0,0 +1,55 @@
+/*
+ * 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_NLP_AUTOML_MODEL_RUNSMARTCALLSERVICERESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_RUNSMARTCALLSERVICERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT RunSmartCallServiceResult : public ServiceResult
+			{
+			public:
+
+
+				RunSmartCallServiceResult();
+				explicit RunSmartCallServiceResult(const std::string &payload);
+				~RunSmartCallServiceResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_RUNSMARTCALLSERVICERESULT_H_

nlp-automl/src/Nlp-automlClient.cc

@@ -231,3 +231,39 @@ Nlp_automlClient::RunPreTrainServiceOutcomeCallable Nlp_automlClient::runPreTrai
 	return task->get_future();
 }
 
+Nlp_automlClient::RunSmartCallServiceOutcome Nlp_automlClient::runSmartCallService(const RunSmartCallServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RunSmartCallServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RunSmartCallServiceOutcome(RunSmartCallServiceResult(outcome.result()));
+	else
+		return RunSmartCallServiceOutcome(outcome.error());
+}
+
+void Nlp_automlClient::runSmartCallServiceAsync(const RunSmartCallServiceRequest& request, const RunSmartCallServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, runSmartCallService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::RunSmartCallServiceOutcomeCallable Nlp_automlClient::runSmartCallServiceCallable(const RunSmartCallServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RunSmartCallServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->runSmartCallService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

nlp-automl/src/model/RunSmartCallServiceRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * 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/nlp-automl/model/RunSmartCallServiceRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::RunSmartCallServiceRequest;
+
+RunSmartCallServiceRequest::RunSmartCallServiceRequest() :
+	RpcServiceRequest("nlp-automl", "2019-11-11", "RunSmartCallService")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+RunSmartCallServiceRequest::~RunSmartCallServiceRequest()
+{}
+
+std::string RunSmartCallServiceRequest::getSessionId()const
+{
+	return sessionId_;
+}
+
+void RunSmartCallServiceRequest::setSessionId(const std::string& sessionId)
+{
+	sessionId_ = sessionId;
+	setBodyParameter("SessionId", sessionId);
+}
+
+long RunSmartCallServiceRequest::getRobotId()const
+{
+	return robotId_;
+}
+
+void RunSmartCallServiceRequest::setRobotId(long robotId)
+{
+	robotId_ = robotId;
+	setBodyParameter("RobotId", std::to_string(robotId));
+}
+
+std::string RunSmartCallServiceRequest::getParamContent()const
+{
+	return paramContent_;
+}
+
+void RunSmartCallServiceRequest::setParamContent(const std::string& paramContent)
+{
+	paramContent_ = paramContent;
+	setBodyParameter("ParamContent", paramContent);
+}
+
+std::string RunSmartCallServiceRequest::getServiceName()const
+{
+	return serviceName_;
+}
+
+void RunSmartCallServiceRequest::setServiceName(const std::string& serviceName)
+{
+	serviceName_ = serviceName;
+	setBodyParameter("ServiceName", serviceName);
+}
+

nlp-automl/src/model/RunSmartCallServiceResult.cc

@@ -0,0 +1,65 @@
+/*
+ * 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/nlp-automl/model/RunSmartCallServiceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nlp_automl;
+using namespace AlibabaCloud::Nlp_automl::Model;
+
+RunSmartCallServiceResult::RunSmartCallServiceResult() :
+	ServiceResult()
+{}
+
+RunSmartCallServiceResult::RunSmartCallServiceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RunSmartCallServiceResult::~RunSmartCallServiceResult()
+{}
+
+void RunSmartCallServiceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+
+}
+
+std::string RunSmartCallServiceResult::getMessage()const
+{
+	return message_;
+}
+
+std::string RunSmartCallServiceResult::getData()const
+{
+	return data_;
+}
+
+int RunSmartCallServiceResult::getCode()const
+{
+	return code_;
+}
+

push/include/alibabacloud/push/model/MassPushRequest.h

@@ -55,6 +55,7 @@ namespace AlibabaCloud
 					std::string expireTime;
 					std::string androidPopupBody;
 					std::string iOSNotificationCategory;
+					std::string androidNotificationXiaomiChannel;
 					bool storeOffline;
 					bool iOSSilentNotification;
 					std::string jobKey;

push/include/alibabacloud/push/model/PushRequest.h

@@ -67,6 +67,8 @@ namespace AlibabaCloud
 				void setExpireTime(const std::string& expireTime);
 				std::string getIOSNotificationCategory()const;
 				void setIOSNotificationCategory(const std::string& iOSNotificationCategory);
+				std::string getAndroidNotificationXiaomiChannel()const;
+				void setAndroidNotificationXiaomiChannel(const std::string& androidNotificationXiaomiChannel);
 				bool getStoreOffline()const;
 				void setStoreOffline(bool storeOffline);
 				std::string getSmsParams()const;
@@ -143,6 +145,7 @@ namespace AlibabaCloud
 				int androidNotificationBarPriority_;
 				std::string expireTime_;
 				std::string iOSNotificationCategory_;
+				std::string androidNotificationXiaomiChannel_;
 				bool storeOffline_;
 				std::string smsParams_;
 				std::string jobKey_;

push/src/model/MassPushRequest.cc

@@ -71,6 +71,7 @@ void MassPushRequest::setPushTask(const std::vector<PushTask>& pushTask)
 		setParameter(pushTaskObjStr + ".ExpireTime", pushTaskObj.expireTime);
 		setParameter(pushTaskObjStr + ".AndroidPopupBody", pushTaskObj.androidPopupBody);
 		setParameter(pushTaskObjStr + ".IOSNotificationCategory", pushTaskObj.iOSNotificationCategory);
+		setParameter(pushTaskObjStr + ".AndroidNotificationXiaomiChannel", pushTaskObj.androidNotificationXiaomiChannel);
 		setParameter(pushTaskObjStr + ".StoreOffline", pushTaskObj.storeOffline ? "true" : "false");
 		setParameter(pushTaskObjStr + ".IOSSilentNotification", pushTaskObj.iOSSilentNotification ? "true" : "false");
 		setParameter(pushTaskObjStr + ".JobKey", pushTaskObj.jobKey);

push/src/model/PushRequest.cc

@@ -203,6 +203,17 @@ void PushRequest::setIOSNotificationCategory(const std::string& iOSNotificationC
 	setParameter("IOSNotificationCategory", iOSNotificationCategory);
 }
 
+std::string PushRequest::getAndroidNotificationXiaomiChannel()const
+{
+	return androidNotificationXiaomiChannel_;
+}
+
+void PushRequest::setAndroidNotificationXiaomiChannel(const std::string& androidNotificationXiaomiChannel)
+{
+	androidNotificationXiaomiChannel_ = androidNotificationXiaomiChannel;
+	setParameter("AndroidNotificationXiaomiChannel", androidNotificationXiaomiChannel);
+}
+
 bool PushRequest::getStoreOffline()const
 {
 	return storeOffline_;

r-kvstore/CMakeLists.txt

@@ -145,6 +145,8 @@ set(r-kvstore_public_header_model
 	include/alibabacloud/r-kvstore/model/ModifyInstanceVpcAuthModeResult.h
 	include/alibabacloud/r-kvstore/model/ModifyIntranetAttributeRequest.h
 	include/alibabacloud/r-kvstore/model/ModifyIntranetAttributeResult.h
+	include/alibabacloud/r-kvstore/model/ModifyResourceGroupRequest.h
+	include/alibabacloud/r-kvstore/model/ModifyResourceGroupResult.h
 	include/alibabacloud/r-kvstore/model/ModifySecurityGroupConfigurationRequest.h
 	include/alibabacloud/r-kvstore/model/ModifySecurityGroupConfigurationResult.h
 	include/alibabacloud/r-kvstore/model/ModifySecurityIpsRequest.h
@@ -298,6 +300,8 @@ set(r-kvstore_src
 	src/model/ModifyInstanceVpcAuthModeResult.cc
 	src/model/ModifyIntranetAttributeRequest.cc
 	src/model/ModifyIntranetAttributeResult.cc
+	src/model/ModifyResourceGroupRequest.cc
+	src/model/ModifyResourceGroupResult.cc
 	src/model/ModifySecurityGroupConfigurationRequest.cc
 	src/model/ModifySecurityGroupConfigurationResult.cc
 	src/model/ModifySecurityIpsRequest.cc

r-kvstore/include/alibabacloud/r-kvstore/R_kvstoreClient.h

@@ -146,6 +146,8 @@
 #include "model/ModifyInstanceVpcAuthModeResult.h"
 #include "model/ModifyIntranetAttributeRequest.h"
 #include "model/ModifyIntranetAttributeResult.h"
+#include "model/ModifyResourceGroupRequest.h"
+#include "model/ModifyResourceGroupResult.h"
 #include "model/ModifySecurityGroupConfigurationRequest.h"
 #include "model/ModifySecurityGroupConfigurationResult.h"
 #include "model/ModifySecurityIpsRequest.h"
@@ -367,6 +369,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyIntranetAttributeResult> ModifyIntranetAttributeOutcome;
 			typedef std::future<ModifyIntranetAttributeOutcome> ModifyIntranetAttributeOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::ModifyIntranetAttributeRequest&, const ModifyIntranetAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyIntranetAttributeAsyncHandler;
+			typedef Outcome<Error, Model::ModifyResourceGroupResult> ModifyResourceGroupOutcome;
+			typedef std::future<ModifyResourceGroupOutcome> ModifyResourceGroupOutcomeCallable;
+			typedef std::function<void(const R_kvstoreClient*, const Model::ModifyResourceGroupRequest&, const ModifyResourceGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyResourceGroupAsyncHandler;
 			typedef Outcome<Error, Model::ModifySecurityGroupConfigurationResult> ModifySecurityGroupConfigurationOutcome;
 			typedef std::future<ModifySecurityGroupConfigurationOutcome> ModifySecurityGroupConfigurationOutcomeCallable;
 			typedef std::function<void(const R_kvstoreClient*, const Model::ModifySecurityGroupConfigurationRequest&, const ModifySecurityGroupConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifySecurityGroupConfigurationAsyncHandler;
@@ -597,6 +602,9 @@ namespace AlibabaCloud
 			ModifyIntranetAttributeOutcome modifyIntranetAttribute(const Model::ModifyIntranetAttributeRequest &request)const;
 			void modifyIntranetAttributeAsync(const Model::ModifyIntranetAttributeRequest& request, const ModifyIntranetAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyIntranetAttributeOutcomeCallable modifyIntranetAttributeCallable(const Model::ModifyIntranetAttributeRequest& request) const;
+			ModifyResourceGroupOutcome modifyResourceGroup(const Model::ModifyResourceGroupRequest &request)const;
+			void modifyResourceGroupAsync(const Model::ModifyResourceGroupRequest& request, const ModifyResourceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyResourceGroupOutcomeCallable modifyResourceGroupCallable(const Model::ModifyResourceGroupRequest& request) const;
 			ModifySecurityGroupConfigurationOutcome modifySecurityGroupConfiguration(const Model::ModifySecurityGroupConfigurationRequest &request)const;
 			void modifySecurityGroupConfigurationAsync(const Model::ModifySecurityGroupConfigurationRequest& request, const ModifySecurityGroupConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifySecurityGroupConfigurationOutcomeCallable modifySecurityGroupConfigurationCallable(const Model::ModifySecurityGroupConfigurationRequest& request) const;

r-kvstore/include/alibabacloud/r-kvstore/model/DescribeInstanceAttributeResult.h

@@ -41,6 +41,7 @@ namespace AlibabaCloud
 					};
 					long connections;
 					std::string endTime;
+					std::string resourceGroupId;
 					std::string config;
 					long port;
 					std::string hasRenewChangeOrder;

r-kvstore/include/alibabacloud/r-kvstore/model/ModifyResourceGroupRequest.h

@@ -0,0 +1,72 @@
+/*
+ * 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_R_KVSTORE_MODEL_MODIFYRESOURCEGROUPREQUEST_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_MODIFYRESOURCEGROUPREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/r-kvstore/R_kvstoreExport.h>
+
+namespace AlibabaCloud
+{
+	namespace R_kvstore
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_R_KVSTORE_EXPORT ModifyResourceGroupRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyResourceGroupRequest();
+				~ModifyResourceGroupRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getResourceGroupId()const;
+				void setResourceGroupId(const std::string& resourceGroupId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+
+            private:
+				long resourceOwnerId_;
+				std::string clientToken_;
+				std::string accessKeyId_;
+				std::string resourceGroupId_;
+				std::string regionId_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string instanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_MODIFYRESOURCEGROUPREQUEST_H_

r-kvstore/include/alibabacloud/r-kvstore/model/ModifyResourceGroupResult.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_R_KVSTORE_MODEL_MODIFYRESOURCEGROUPRESULT_H_
+#define ALIBABACLOUD_R_KVSTORE_MODEL_MODIFYRESOURCEGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/r-kvstore/R_kvstoreExport.h>
+
+namespace AlibabaCloud
+{
+	namespace R_kvstore
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_R_KVSTORE_EXPORT ModifyResourceGroupResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyResourceGroupResult();
+				explicit ModifyResourceGroupResult(const std::string &payload);
+				~ModifyResourceGroupResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_R_KVSTORE_MODEL_MODIFYRESOURCEGROUPRESULT_H_

r-kvstore/include/alibabacloud/r-kvstore/model/ModifySecurityIpsRequest.h

@@ -45,6 +45,8 @@ namespace AlibabaCloud
 				void setSecurityIpGroupName(const std::string& securityIpGroupName);
 				std::string getSecurityToken()const;
 				void setSecurityToken(const std::string& securityToken);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
 				std::string getModifyMode()const;
 				void setModifyMode(const std::string& modifyMode);
 				std::string getResourceOwnerAccount()const;
@@ -64,6 +66,7 @@ namespace AlibabaCloud
 				std::string accessKeyId_;
 				std::string securityIpGroupName_;
 				std::string securityToken_;
+				std::string regionId_;
 				std::string modifyMode_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;

r-kvstore/src/R-kvstoreClient.cc

@@ -2283,6 +2283,42 @@ R_kvstoreClient::ModifyIntranetAttributeOutcomeCallable R_kvstoreClient::modifyI
 	return task->get_future();
 }
 
+R_kvstoreClient::ModifyResourceGroupOutcome R_kvstoreClient::modifyResourceGroup(const ModifyResourceGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyResourceGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyResourceGroupOutcome(ModifyResourceGroupResult(outcome.result()));
+	else
+		return ModifyResourceGroupOutcome(outcome.error());
+}
+
+void R_kvstoreClient::modifyResourceGroupAsync(const ModifyResourceGroupRequest& request, const ModifyResourceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyResourceGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+R_kvstoreClient::ModifyResourceGroupOutcomeCallable R_kvstoreClient::modifyResourceGroupCallable(const ModifyResourceGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyResourceGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyResourceGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 R_kvstoreClient::ModifySecurityGroupConfigurationOutcome R_kvstoreClient::modifySecurityGroupConfiguration(const ModifySecurityGroupConfigurationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

r-kvstore/src/model/DescribeInstanceAttributeResult.cc

@@ -121,6 +121,8 @@ void DescribeInstanceAttributeResult::parse(const std::string &payload)
 			instancesObject.vpcCloudInstanceId = valueInstancesDBInstanceAttribute["VpcCloudInstanceId"].asString();
 		if(!valueInstancesDBInstanceAttribute["InstanceReleaseProtection"].isNull())
 			instancesObject.instanceReleaseProtection = valueInstancesDBInstanceAttribute["InstanceReleaseProtection"].asString() == "true";
+		if(!valueInstancesDBInstanceAttribute["ResourceGroupId"].isNull())
+			instancesObject.resourceGroupId = valueInstancesDBInstanceAttribute["ResourceGroupId"].asString();
 		auto allTagsNode = allInstancesNode["Tags"]["Tag"];
 		for (auto allInstancesNodeTagsTag : allTagsNode)
 		{

r-kvstore/src/model/ModifyResourceGroupRequest.cc

@@ -0,0 +1,128 @@
+/*
+ * 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/r-kvstore/model/ModifyResourceGroupRequest.h>
+
+using AlibabaCloud::R_kvstore::Model::ModifyResourceGroupRequest;
+
+ModifyResourceGroupRequest::ModifyResourceGroupRequest() :
+	RpcServiceRequest("r-kvstore", "2015-01-01", "ModifyResourceGroup")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ModifyResourceGroupRequest::~ModifyResourceGroupRequest()
+{}
+
+long ModifyResourceGroupRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void ModifyResourceGroupRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string ModifyResourceGroupRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void ModifyResourceGroupRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string ModifyResourceGroupRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ModifyResourceGroupRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string ModifyResourceGroupRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void ModifyResourceGroupRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setParameter("ResourceGroupId", resourceGroupId);
+}
+
+std::string ModifyResourceGroupRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ModifyResourceGroupRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string ModifyResourceGroupRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ModifyResourceGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ModifyResourceGroupRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void ModifyResourceGroupRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long ModifyResourceGroupRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ModifyResourceGroupRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string ModifyResourceGroupRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void ModifyResourceGroupRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

r-kvstore/src/model/ModifyResourceGroupResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/r-kvstore/model/ModifyResourceGroupResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::R_kvstore;
+using namespace AlibabaCloud::R_kvstore::Model;
+
+ModifyResourceGroupResult::ModifyResourceGroupResult() :
+	ServiceResult()
+{}
+
+ModifyResourceGroupResult::ModifyResourceGroupResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ModifyResourceGroupResult::~ModifyResourceGroupResult()
+{}
+
+void ModifyResourceGroupResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

r-kvstore/src/model/ModifySecurityIpsRequest.cc

@@ -82,6 +82,17 @@ void ModifySecurityIpsRequest::setSecurityToken(const std::string& securityToken
 	setParameter("SecurityToken", securityToken);
 }
 
+std::string ModifySecurityIpsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ModifySecurityIpsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
 std::string ModifySecurityIpsRequest::getModifyMode()const
 {
 	return modifyMode_;

sas/CMakeLists.txt

@@ -163,6 +163,8 @@ set(sas_public_header_model
 	include/alibabacloud/sas/model/DescribeWarningMachinesResult.h
 	include/alibabacloud/sas/model/ExportRecordRequest.h
 	include/alibabacloud/sas/model/ExportRecordResult.h
+	include/alibabacloud/sas/model/FixCheckWarningsRequest.h
+	include/alibabacloud/sas/model/FixCheckWarningsResult.h
 	include/alibabacloud/sas/model/GetIOCsRequest.h
 	include/alibabacloud/sas/model/GetIOCsResult.h
 	include/alibabacloud/sas/model/GetIncIOCsRequest.h
@@ -171,14 +173,8 @@ set(sas_public_header_model
 	include/alibabacloud/sas/model/HandleSimilarSecurityEventsResult.h
 	include/alibabacloud/sas/model/ModifyAntiBruteForceRuleRequest.h
 	include/alibabacloud/sas/model/ModifyAntiBruteForceRuleResult.h
-	include/alibabacloud/sas/model/ModifyAutoDelConfigRequest.h
-	include/alibabacloud/sas/model/ModifyAutoDelConfigResult.h
-	include/alibabacloud/sas/model/ModifyConcernNecessityRequest.h
-	include/alibabacloud/sas/model/ModifyConcernNecessityResult.h
 	include/alibabacloud/sas/model/ModifyCreateVulWhitelistRequest.h
 	include/alibabacloud/sas/model/ModifyCreateVulWhitelistResult.h
-	include/alibabacloud/sas/model/ModifyDeleteVulWhitelistRequest.h
-	include/alibabacloud/sas/model/ModifyDeleteVulWhitelistResult.h
 	include/alibabacloud/sas/model/ModifyEmgVulSubmitRequest.h
 	include/alibabacloud/sas/model/ModifyEmgVulSubmitResult.h
 	include/alibabacloud/sas/model/ModifyGroupPropertyRequest.h
@@ -214,7 +210,9 @@ set(sas_public_header_model
 	include/alibabacloud/sas/model/SasInstallCodeRequest.h
 	include/alibabacloud/sas/model/SasInstallCodeResult.h
 	include/alibabacloud/sas/model/StartBaselineSecurityCheckRequest.h
-	include/alibabacloud/sas/model/StartBaselineSecurityCheckResult.h )
+	include/alibabacloud/sas/model/StartBaselineSecurityCheckResult.h
+	include/alibabacloud/sas/model/ValidateHcWarningsRequest.h
+	include/alibabacloud/sas/model/ValidateHcWarningsResult.h )
 
 set(sas_src 
 	src/SasClient.cc
@@ -360,6 +358,8 @@ set(sas_src
 	src/model/DescribeWarningMachinesResult.cc
 	src/model/ExportRecordRequest.cc
 	src/model/ExportRecordResult.cc
+	src/model/FixCheckWarningsRequest.cc
+	src/model/FixCheckWarningsResult.cc
 	src/model/GetIOCsRequest.cc
 	src/model/GetIOCsResult.cc
 	src/model/GetIncIOCsRequest.cc
@@ -368,14 +368,8 @@ set(sas_src
 	src/model/HandleSimilarSecurityEventsResult.cc
 	src/model/ModifyAntiBruteForceRuleRequest.cc
 	src/model/ModifyAntiBruteForceRuleResult.cc
-	src/model/ModifyAutoDelConfigRequest.cc
-	src/model/ModifyAutoDelConfigResult.cc
-	src/model/ModifyConcernNecessityRequest.cc
-	src/model/ModifyConcernNecessityResult.cc
 	src/model/ModifyCreateVulWhitelistRequest.cc
 	src/model/ModifyCreateVulWhitelistResult.cc
-	src/model/ModifyDeleteVulWhitelistRequest.cc
-	src/model/ModifyDeleteVulWhitelistResult.cc
 	src/model/ModifyEmgVulSubmitRequest.cc
 	src/model/ModifyEmgVulSubmitResult.cc
 	src/model/ModifyGroupPropertyRequest.cc
@@ -411,7 +405,9 @@ set(sas_src
 	src/model/SasInstallCodeRequest.cc
 	src/model/SasInstallCodeResult.cc
 	src/model/StartBaselineSecurityCheckRequest.cc
-	src/model/StartBaselineSecurityCheckResult.cc )
+	src/model/StartBaselineSecurityCheckResult.cc
+	src/model/ValidateHcWarningsRequest.cc
+	src/model/ValidateHcWarningsResult.cc )
 
 add_library(sas ${LIB_TYPE}
 	${sas_public_header}

sas/include/alibabacloud/sas/SasClient.h

@@ -164,6 +164,8 @@
 #include "model/DescribeWarningMachinesResult.h"
 #include "model/ExportRecordRequest.h"
 #include "model/ExportRecordResult.h"
+#include "model/FixCheckWarningsRequest.h"
+#include "model/FixCheckWarningsResult.h"
 #include "model/GetIOCsRequest.h"
 #include "model/GetIOCsResult.h"
 #include "model/GetIncIOCsRequest.h"
@@ -172,14 +174,8 @@
 #include "model/HandleSimilarSecurityEventsResult.h"
 #include "model/ModifyAntiBruteForceRuleRequest.h"
 #include "model/ModifyAntiBruteForceRuleResult.h"
-#include "model/ModifyAutoDelConfigRequest.h"
-#include "model/ModifyAutoDelConfigResult.h"
-#include "model/ModifyConcernNecessityRequest.h"
-#include "model/ModifyConcernNecessityResult.h"
 #include "model/ModifyCreateVulWhitelistRequest.h"
 #include "model/ModifyCreateVulWhitelistResult.h"
-#include "model/ModifyDeleteVulWhitelistRequest.h"
-#include "model/ModifyDeleteVulWhitelistResult.h"
 #include "model/ModifyEmgVulSubmitRequest.h"
 #include "model/ModifyEmgVulSubmitResult.h"
 #include "model/ModifyGroupPropertyRequest.h"
@@ -216,6 +212,8 @@
 #include "model/SasInstallCodeResult.h"
 #include "model/StartBaselineSecurityCheckRequest.h"
 #include "model/StartBaselineSecurityCheckResult.h"
+#include "model/ValidateHcWarningsRequest.h"
+#include "model/ValidateHcWarningsResult.h"
 
 
 namespace AlibabaCloud
@@ -438,6 +436,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ExportRecordResult> ExportRecordOutcome;
 			typedef std::future<ExportRecordOutcome> ExportRecordOutcomeCallable;
 			typedef std::function<void(const SasClient*, const Model::ExportRecordRequest&, const ExportRecordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExportRecordAsyncHandler;
+			typedef Outcome<Error, Model::FixCheckWarningsResult> FixCheckWarningsOutcome;
+			typedef std::future<FixCheckWarningsOutcome> FixCheckWarningsOutcomeCallable;
+			typedef std::function<void(const SasClient*, const Model::FixCheckWarningsRequest&, const FixCheckWarningsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FixCheckWarningsAsyncHandler;
 			typedef Outcome<Error, Model::GetIOCsResult> GetIOCsOutcome;
 			typedef std::future<GetIOCsOutcome> GetIOCsOutcomeCallable;
 			typedef std::function<void(const SasClient*, const Model::GetIOCsRequest&, const GetIOCsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetIOCsAsyncHandler;
@@ -450,18 +451,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyAntiBruteForceRuleResult> ModifyAntiBruteForceRuleOutcome;
 			typedef std::future<ModifyAntiBruteForceRuleOutcome> ModifyAntiBruteForceRuleOutcomeCallable;
 			typedef std::function<void(const SasClient*, const Model::ModifyAntiBruteForceRuleRequest&, const ModifyAntiBruteForceRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAntiBruteForceRuleAsyncHandler;
-			typedef Outcome<Error, Model::ModifyAutoDelConfigResult> ModifyAutoDelConfigOutcome;
-			typedef std::future<ModifyAutoDelConfigOutcome> ModifyAutoDelConfigOutcomeCallable;
-			typedef std::function<void(const SasClient*, const Model::ModifyAutoDelConfigRequest&, const ModifyAutoDelConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAutoDelConfigAsyncHandler;
-			typedef Outcome<Error, Model::ModifyConcernNecessityResult> ModifyConcernNecessityOutcome;
-			typedef std::future<ModifyConcernNecessityOutcome> ModifyConcernNecessityOutcomeCallable;
-			typedef std::function<void(const SasClient*, const Model::ModifyConcernNecessityRequest&, const ModifyConcernNecessityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyConcernNecessityAsyncHandler;
 			typedef Outcome<Error, Model::ModifyCreateVulWhitelistResult> ModifyCreateVulWhitelistOutcome;
 			typedef std::future<ModifyCreateVulWhitelistOutcome> ModifyCreateVulWhitelistOutcomeCallable;
 			typedef std::function<void(const SasClient*, const Model::ModifyCreateVulWhitelistRequest&, const ModifyCreateVulWhitelistOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyCreateVulWhitelistAsyncHandler;
-			typedef Outcome<Error, Model::ModifyDeleteVulWhitelistResult> ModifyDeleteVulWhitelistOutcome;
-			typedef std::future<ModifyDeleteVulWhitelistOutcome> ModifyDeleteVulWhitelistOutcomeCallable;
-			typedef std::function<void(const SasClient*, const Model::ModifyDeleteVulWhitelistRequest&, const ModifyDeleteVulWhitelistOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDeleteVulWhitelistAsyncHandler;
 			typedef Outcome<Error, Model::ModifyEmgVulSubmitResult> ModifyEmgVulSubmitOutcome;
 			typedef std::future<ModifyEmgVulSubmitOutcome> ModifyEmgVulSubmitOutcomeCallable;
 			typedef std::function<void(const SasClient*, const Model::ModifyEmgVulSubmitRequest&, const ModifyEmgVulSubmitOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyEmgVulSubmitAsyncHandler;
@@ -516,6 +508,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::StartBaselineSecurityCheckResult> StartBaselineSecurityCheckOutcome;
 			typedef std::future<StartBaselineSecurityCheckOutcome> StartBaselineSecurityCheckOutcomeCallable;
 			typedef std::function<void(const SasClient*, const Model::StartBaselineSecurityCheckRequest&, const StartBaselineSecurityCheckOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartBaselineSecurityCheckAsyncHandler;
+			typedef Outcome<Error, Model::ValidateHcWarningsResult> ValidateHcWarningsOutcome;
+			typedef std::future<ValidateHcWarningsOutcome> ValidateHcWarningsOutcomeCallable;
+			typedef std::function<void(const SasClient*, const Model::ValidateHcWarningsRequest&, const ValidateHcWarningsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ValidateHcWarningsAsyncHandler;
 
 			SasClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			SasClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -734,6 +729,9 @@ namespace AlibabaCloud
 			ExportRecordOutcome exportRecord(const Model::ExportRecordRequest &request)const;
 			void exportRecordAsync(const Model::ExportRecordRequest& request, const ExportRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ExportRecordOutcomeCallable exportRecordCallable(const Model::ExportRecordRequest& request) const;
+			FixCheckWarningsOutcome fixCheckWarnings(const Model::FixCheckWarningsRequest &request)const;
+			void fixCheckWarningsAsync(const Model::FixCheckWarningsRequest& request, const FixCheckWarningsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			FixCheckWarningsOutcomeCallable fixCheckWarningsCallable(const Model::FixCheckWarningsRequest& request) const;
 			GetIOCsOutcome getIOCs(const Model::GetIOCsRequest &request)const;
 			void getIOCsAsync(const Model::GetIOCsRequest& request, const GetIOCsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetIOCsOutcomeCallable getIOCsCallable(const Model::GetIOCsRequest& request) const;
@@ -746,18 +744,9 @@ namespace AlibabaCloud
 			ModifyAntiBruteForceRuleOutcome modifyAntiBruteForceRule(const Model::ModifyAntiBruteForceRuleRequest &request)const;
 			void modifyAntiBruteForceRuleAsync(const Model::ModifyAntiBruteForceRuleRequest& request, const ModifyAntiBruteForceRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyAntiBruteForceRuleOutcomeCallable modifyAntiBruteForceRuleCallable(const Model::ModifyAntiBruteForceRuleRequest& request) const;
-			ModifyAutoDelConfigOutcome modifyAutoDelConfig(const Model::ModifyAutoDelConfigRequest &request)const;
-			void modifyAutoDelConfigAsync(const Model::ModifyAutoDelConfigRequest& request, const ModifyAutoDelConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ModifyAutoDelConfigOutcomeCallable modifyAutoDelConfigCallable(const Model::ModifyAutoDelConfigRequest& request) const;
-			ModifyConcernNecessityOutcome modifyConcernNecessity(const Model::ModifyConcernNecessityRequest &request)const;
-			void modifyConcernNecessityAsync(const Model::ModifyConcernNecessityRequest& request, const ModifyConcernNecessityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ModifyConcernNecessityOutcomeCallable modifyConcernNecessityCallable(const Model::ModifyConcernNecessityRequest& request) const;
 			ModifyCreateVulWhitelistOutcome modifyCreateVulWhitelist(const Model::ModifyCreateVulWhitelistRequest &request)const;
 			void modifyCreateVulWhitelistAsync(const Model::ModifyCreateVulWhitelistRequest& request, const ModifyCreateVulWhitelistAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyCreateVulWhitelistOutcomeCallable modifyCreateVulWhitelistCallable(const Model::ModifyCreateVulWhitelistRequest& request) const;
-			ModifyDeleteVulWhitelistOutcome modifyDeleteVulWhitelist(const Model::ModifyDeleteVulWhitelistRequest &request)const;
-			void modifyDeleteVulWhitelistAsync(const Model::ModifyDeleteVulWhitelistRequest& request, const ModifyDeleteVulWhitelistAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ModifyDeleteVulWhitelistOutcomeCallable modifyDeleteVulWhitelistCallable(const Model::ModifyDeleteVulWhitelistRequest& request) const;
 			ModifyEmgVulSubmitOutcome modifyEmgVulSubmit(const Model::ModifyEmgVulSubmitRequest &request)const;
 			void modifyEmgVulSubmitAsync(const Model::ModifyEmgVulSubmitRequest& request, const ModifyEmgVulSubmitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyEmgVulSubmitOutcomeCallable modifyEmgVulSubmitCallable(const Model::ModifyEmgVulSubmitRequest& request) const;
@@ -812,6 +801,9 @@ namespace AlibabaCloud
 			StartBaselineSecurityCheckOutcome startBaselineSecurityCheck(const Model::StartBaselineSecurityCheckRequest &request)const;
 			void startBaselineSecurityCheckAsync(const Model::StartBaselineSecurityCheckRequest& request, const StartBaselineSecurityCheckAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StartBaselineSecurityCheckOutcomeCallable startBaselineSecurityCheckCallable(const Model::StartBaselineSecurityCheckRequest& request) const;
+			ValidateHcWarningsOutcome validateHcWarnings(const Model::ValidateHcWarningsRequest &request)const;
+			void validateHcWarningsAsync(const Model::ValidateHcWarningsRequest& request, const ValidateHcWarningsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ValidateHcWarningsOutcomeCallable validateHcWarningsCallable(const Model::ValidateHcWarningsRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

sas/include/alibabacloud/sas/model/DescribeRiskCheckSummaryRequest.h

@@ -41,11 +41,14 @@ namespace AlibabaCloud
 				void setSourceIp(const std::string& sourceIp);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
+				std::string getResourceDirectoryAccountId()const;
+				void setResourceDirectoryAccountId(const std::string& resourceDirectoryAccountId);
 
             private:
 				long resourceOwnerId_;
 				std::string sourceIp_;
 				std::string lang_;
+				std::string resourceDirectoryAccountId_;
 
 			};
 		}

sas/include/alibabacloud/sas/model/DescribeSecurityStatInfoRequest.h

@@ -39,10 +39,13 @@ namespace AlibabaCloud
 				void setSourceIp(const std::string& sourceIp);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
+				std::string getResourceDirectoryAccountId()const;
+				void setResourceDirectoryAccountId(const std::string& resourceDirectoryAccountId);
 
             private:
 				std::string sourceIp_;
 				std::string lang_;
+				std::string resourceDirectoryAccountId_;
 
 			};
 		}

sas/include/alibabacloud/sas/model/DescribeSummaryInfoRequest.h

@@ -39,10 +39,13 @@ namespace AlibabaCloud
 				void setSourceIp(const std::string& sourceIp);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
+				std::string getResourceDirectoryAccountId()const;
+				void setResourceDirectoryAccountId(const std::string& resourceDirectoryAccountId);
 
             private:
 				std::string sourceIp_;
 				std::string lang_;
+				std::string resourceDirectoryAccountId_;
 
 			};
 		}

sas/include/alibabacloud/sas/model/DescribeSuspEventDetailResult.h

@@ -46,6 +46,7 @@ namespace AlibabaCloud
 				~DescribeSuspEventDetailResult();
 				std::string getEventDesc()const;
 				std::string getEventTypeDesc()const;
+				std::string getOperateErrorCode()const;
 				std::string getEventStatus()const;
 				std::string getEventName()const;
 				std::string getSaleVersion()const;
@@ -68,6 +69,7 @@ namespace AlibabaCloud
 			private:
 				std::string eventDesc_;
 				std::string eventTypeDesc_;
+				std::string operateErrorCode_;
 				std::string eventStatus_;
 				std::string eventName_;
 				std::string saleVersion_;

sas/include/alibabacloud/sas/model/FixCheckWarningsRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SAS_MODEL_MODIFYCONCERNNECESSITYREQUEST_H_
-#define ALIBABACLOUD_SAS_MODEL_MODIFYCONCERNNECESSITYREQUEST_H_
+#ifndef ALIBABACLOUD_SAS_MODEL_FIXCHECKWARNINGSREQUEST_H_
+#define ALIBABACLOUD_SAS_MODEL_FIXCHECKWARNINGSREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,27 +28,33 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SAS_EXPORT ModifyConcernNecessityRequest : public RpcServiceRequest
+			class ALIBABACLOUD_SAS_EXPORT FixCheckWarningsRequest : public RpcServiceRequest
 			{
 
 			public:
-				ModifyConcernNecessityRequest();
-				~ModifyConcernNecessityRequest();
+				FixCheckWarningsRequest();
+				~FixCheckWarningsRequest();
 
+				long getRiskId()const;
+				void setRiskId(long riskId);
+				std::string getCheckParams()const;
+				void setCheckParams(const std::string& checkParams);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
-				std::string getConcernNecessity()const;
-				void setConcernNecessity(const std::string& concernNecessity);
+				std::string getUuids()const;
+				void setUuids(const std::string& uuids);
 
             private:
+				long riskId_;
+				std::string checkParams_;
 				std::string sourceIp_;
 				std::string lang_;
-				std::string concernNecessity_;
+				std::string uuids_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SAS_MODEL_MODIFYCONCERNNECESSITYREQUEST_H_
+#endif // !ALIBABACLOUD_SAS_MODEL_FIXCHECKWARNINGSREQUEST_H_

sas/include/alibabacloud/sas/model/FixCheckWarningsResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SAS_MODEL_MODIFYCONCERNNECESSITYRESULT_H_
-#define ALIBABACLOUD_SAS_MODEL_MODIFYCONCERNNECESSITYRESULT_H_
+#ifndef ALIBABACLOUD_SAS_MODEL_FIXCHECKWARNINGSRESULT_H_
+#define ALIBABACLOUD_SAS_MODEL_FIXCHECKWARNINGSRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,21 +29,23 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SAS_EXPORT ModifyConcernNecessityResult : public ServiceResult
+			class ALIBABACLOUD_SAS_EXPORT FixCheckWarningsResult : public ServiceResult
 			{
 			public:
 
 
-				ModifyConcernNecessityResult();
-				explicit ModifyConcernNecessityResult(const std::string &payload);
-				~ModifyConcernNecessityResult();
+				FixCheckWarningsResult();
+				explicit FixCheckWarningsResult(const std::string &payload);
+				~FixCheckWarningsResult();
+				long getBatchId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				long batchId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SAS_MODEL_MODIFYCONCERNNECESSITYRESULT_H_
+#endif // !ALIBABACLOUD_SAS_MODEL_FIXCHECKWARNINGSRESULT_H_

sas/include/alibabacloud/sas/model/GetIOCsRequest.h

@@ -35,12 +35,15 @@ namespace AlibabaCloud
 				GetIOCsRequest();
 				~GetIOCsRequest();
 
+				std::string getDate()const;
+				void setDate(const std::string& date);
 				std::string getType()const;
 				void setType(const std::string& type);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
 
             private:
+				std::string date_;
 				std::string type_;
 				std::string sourceIp_;
 

sas/include/alibabacloud/sas/model/ValidateHcWarningsRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SAS_MODEL_MODIFYDELETEVULWHITELISTREQUEST_H_
-#define ALIBABACLOUD_SAS_MODEL_MODIFYDELETEVULWHITELISTREQUEST_H_
+#ifndef ALIBABACLOUD_SAS_MODEL_VALIDATEHCWARNINGSREQUEST_H_
+#define ALIBABACLOUD_SAS_MODEL_VALIDATEHCWARNINGSREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,24 +28,27 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SAS_EXPORT ModifyDeleteVulWhitelistRequest : public RpcServiceRequest
+			class ALIBABACLOUD_SAS_EXPORT ValidateHcWarningsRequest : public RpcServiceRequest
 			{
 
 			public:
-				ModifyDeleteVulWhitelistRequest();
-				~ModifyDeleteVulWhitelistRequest();
+				ValidateHcWarningsRequest();
+				~ValidateHcWarningsRequest();
 
+				std::string getRiskIds()const;
+				void setRiskIds(const std::string& riskIds);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
-				std::string getWhitelist()const;
-				void setWhitelist(const std::string& whitelist);
+				std::string getUuids()const;
+				void setUuids(const std::string& uuids);
 
             private:
+				std::string riskIds_;
 				std::string sourceIp_;
-				std::string whitelist_;
+				std::string uuids_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SAS_MODEL_MODIFYDELETEVULWHITELISTREQUEST_H_
+#endif // !ALIBABACLOUD_SAS_MODEL_VALIDATEHCWARNINGSREQUEST_H_

sas/include/alibabacloud/sas/model/ValidateHcWarningsResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SAS_MODEL_MODIFYAUTODELCONFIGRESULT_H_
-#define ALIBABACLOUD_SAS_MODEL_MODIFYAUTODELCONFIGRESULT_H_
+#ifndef ALIBABACLOUD_SAS_MODEL_VALIDATEHCWARNINGSRESULT_H_
+#define ALIBABACLOUD_SAS_MODEL_VALIDATEHCWARNINGSRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,14 +29,14 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SAS_EXPORT ModifyAutoDelConfigResult : public ServiceResult
+			class ALIBABACLOUD_SAS_EXPORT ValidateHcWarningsResult : public ServiceResult
 			{
 			public:
 
 
-				ModifyAutoDelConfigResult();
-				explicit ModifyAutoDelConfigResult(const std::string &payload);
-				~ModifyAutoDelConfigResult();
+				ValidateHcWarningsResult();
+				explicit ValidateHcWarningsResult(const std::string &payload);
+				~ValidateHcWarningsResult();
 
 			protected:
 				void parse(const std::string &payload);
@@ -46,4 +46,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SAS_MODEL_MODIFYAUTODELCONFIGRESULT_H_
+#endif // !ALIBABACLOUD_SAS_MODEL_VALIDATEHCWARNINGSRESULT_H_

sas/src/SasClient.cc

@@ -2607,6 +2607,42 @@ SasClient::ExportRecordOutcomeCallable SasClient::exportRecordCallable(const Exp
 	return task->get_future();
 }
 
+SasClient::FixCheckWarningsOutcome SasClient::fixCheckWarnings(const FixCheckWarningsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return FixCheckWarningsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return FixCheckWarningsOutcome(FixCheckWarningsResult(outcome.result()));
+	else
+		return FixCheckWarningsOutcome(outcome.error());
+}
+
+void SasClient::fixCheckWarningsAsync(const FixCheckWarningsRequest& request, const FixCheckWarningsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, fixCheckWarnings(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SasClient::FixCheckWarningsOutcomeCallable SasClient::fixCheckWarningsCallable(const FixCheckWarningsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<FixCheckWarningsOutcome()>>(
+			[this, request]()
+			{
+			return this->fixCheckWarnings(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SasClient::GetIOCsOutcome SasClient::getIOCs(const GetIOCsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2751,78 +2787,6 @@ SasClient::ModifyAntiBruteForceRuleOutcomeCallable SasClient::modifyAntiBruteFor
 	return task->get_future();
 }
 
-SasClient::ModifyAutoDelConfigOutcome SasClient::modifyAutoDelConfig(const ModifyAutoDelConfigRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return ModifyAutoDelConfigOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return ModifyAutoDelConfigOutcome(ModifyAutoDelConfigResult(outcome.result()));
-	else
-		return ModifyAutoDelConfigOutcome(outcome.error());
-}
-
-void SasClient::modifyAutoDelConfigAsync(const ModifyAutoDelConfigRequest& request, const ModifyAutoDelConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, modifyAutoDelConfig(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SasClient::ModifyAutoDelConfigOutcomeCallable SasClient::modifyAutoDelConfigCallable(const ModifyAutoDelConfigRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<ModifyAutoDelConfigOutcome()>>(
-			[this, request]()
-			{
-			return this->modifyAutoDelConfig(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-SasClient::ModifyConcernNecessityOutcome SasClient::modifyConcernNecessity(const ModifyConcernNecessityRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return ModifyConcernNecessityOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return ModifyConcernNecessityOutcome(ModifyConcernNecessityResult(outcome.result()));
-	else
-		return ModifyConcernNecessityOutcome(outcome.error());
-}
-
-void SasClient::modifyConcernNecessityAsync(const ModifyConcernNecessityRequest& request, const ModifyConcernNecessityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, modifyConcernNecessity(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SasClient::ModifyConcernNecessityOutcomeCallable SasClient::modifyConcernNecessityCallable(const ModifyConcernNecessityRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<ModifyConcernNecessityOutcome()>>(
-			[this, request]()
-			{
-			return this->modifyConcernNecessity(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 SasClient::ModifyCreateVulWhitelistOutcome SasClient::modifyCreateVulWhitelist(const ModifyCreateVulWhitelistRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2859,42 +2823,6 @@ SasClient::ModifyCreateVulWhitelistOutcomeCallable SasClient::modifyCreateVulWhi
 	return task->get_future();
 }
 
-SasClient::ModifyDeleteVulWhitelistOutcome SasClient::modifyDeleteVulWhitelist(const ModifyDeleteVulWhitelistRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return ModifyDeleteVulWhitelistOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return ModifyDeleteVulWhitelistOutcome(ModifyDeleteVulWhitelistResult(outcome.result()));
-	else
-		return ModifyDeleteVulWhitelistOutcome(outcome.error());
-}
-
-void SasClient::modifyDeleteVulWhitelistAsync(const ModifyDeleteVulWhitelistRequest& request, const ModifyDeleteVulWhitelistAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, modifyDeleteVulWhitelist(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SasClient::ModifyDeleteVulWhitelistOutcomeCallable SasClient::modifyDeleteVulWhitelistCallable(const ModifyDeleteVulWhitelistRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<ModifyDeleteVulWhitelistOutcome()>>(
-			[this, request]()
-			{
-			return this->modifyDeleteVulWhitelist(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 SasClient::ModifyEmgVulSubmitOutcome SasClient::modifyEmgVulSubmit(const ModifyEmgVulSubmitRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3543,3 +3471,39 @@ SasClient::StartBaselineSecurityCheckOutcomeCallable SasClient::startBaselineSec
 	return task->get_future();
 }
 
+SasClient::ValidateHcWarningsOutcome SasClient::validateHcWarnings(const ValidateHcWarningsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ValidateHcWarningsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ValidateHcWarningsOutcome(ValidateHcWarningsResult(outcome.result()));
+	else
+		return ValidateHcWarningsOutcome(outcome.error());
+}
+
+void SasClient::validateHcWarningsAsync(const ValidateHcWarningsRequest& request, const ValidateHcWarningsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, validateHcWarnings(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SasClient::ValidateHcWarningsOutcomeCallable SasClient::validateHcWarningsCallable(const ValidateHcWarningsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ValidateHcWarningsOutcome()>>(
+			[this, request]()
+			{
+			return this->validateHcWarnings(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

sas/src/model/DescribeRiskCheckSummaryRequest.cc

@@ -60,3 +60,14 @@ void DescribeRiskCheckSummaryRequest::setLang(const std::string& lang)
 	setParameter("Lang", lang);
 }
 
+std::string DescribeRiskCheckSummaryRequest::getResourceDirectoryAccountId()const
+{
+	return resourceDirectoryAccountId_;
+}
+
+void DescribeRiskCheckSummaryRequest::setResourceDirectoryAccountId(const std::string& resourceDirectoryAccountId)
+{
+	resourceDirectoryAccountId_ = resourceDirectoryAccountId;
+	setParameter("ResourceDirectoryAccountId", resourceDirectoryAccountId);
+}
+

sas/src/model/DescribeSecurityStatInfoRequest.cc

@@ -49,3 +49,14 @@ void DescribeSecurityStatInfoRequest::setLang(const std::string& lang)
 	setParameter("Lang", lang);
 }
 
+std::string DescribeSecurityStatInfoRequest::getResourceDirectoryAccountId()const
+{
+	return resourceDirectoryAccountId_;
+}
+
+void DescribeSecurityStatInfoRequest::setResourceDirectoryAccountId(const std::string& resourceDirectoryAccountId)
+{
+	resourceDirectoryAccountId_ = resourceDirectoryAccountId;
+	setParameter("ResourceDirectoryAccountId", resourceDirectoryAccountId);
+}
+

sas/src/model/DescribeSummaryInfoRequest.cc

@@ -49,3 +49,14 @@ void DescribeSummaryInfoRequest::setLang(const std::string& lang)
 	setParameter("Lang", lang);
 }
 
+std::string DescribeSummaryInfoRequest::getResourceDirectoryAccountId()const
+{
+	return resourceDirectoryAccountId_;
+}
+
+void DescribeSummaryInfoRequest::setResourceDirectoryAccountId(const std::string& resourceDirectoryAccountId)
+{
+	resourceDirectoryAccountId_ = resourceDirectoryAccountId;
+	setParameter("ResourceDirectoryAccountId", resourceDirectoryAccountId);
+}
+

sas/src/model/DescribeSuspEventDetailResult.cc

@@ -87,6 +87,8 @@ void DescribeSuspEventDetailResult::parse(const std::string &payload)
 		eventName_ = value["EventName"].asString();
 	if(!value["CanBeDealOnLine"].isNull())
 		canBeDealOnLine_ = value["CanBeDealOnLine"].asString() == "true";
+	if(!value["OperateErrorCode"].isNull())
+		operateErrorCode_ = value["OperateErrorCode"].asString();
 
 }
 
@@ -100,6 +102,11 @@ std::string DescribeSuspEventDetailResult::getEventTypeDesc()const
 	return eventTypeDesc_;
 }
 
+std::string DescribeSuspEventDetailResult::getOperateErrorCode()const
+{
+	return operateErrorCode_;
+}
+
 std::string DescribeSuspEventDetailResult::getEventStatus()const
 {
 	return eventStatus_;

sas/src/model/FixCheckWarningsRequest.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/sas/model/FixCheckWarningsRequest.h>
+
+using AlibabaCloud::Sas::Model::FixCheckWarningsRequest;
+
+FixCheckWarningsRequest::FixCheckWarningsRequest() :
+	RpcServiceRequest("sas", "2018-12-03", "FixCheckWarnings")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+FixCheckWarningsRequest::~FixCheckWarningsRequest()
+{}
+
+long FixCheckWarningsRequest::getRiskId()const
+{
+	return riskId_;
+}
+
+void FixCheckWarningsRequest::setRiskId(long riskId)
+{
+	riskId_ = riskId;
+	setParameter("RiskId", std::to_string(riskId));
+}
+
+std::string FixCheckWarningsRequest::getCheckParams()const
+{
+	return checkParams_;
+}
+
+void FixCheckWarningsRequest::setCheckParams(const std::string& checkParams)
+{
+	checkParams_ = checkParams;
+	setParameter("CheckParams", checkParams);
+}
+
+std::string FixCheckWarningsRequest::getSourceIp()const
+{
+	return sourceIp_;
+}
+
+void FixCheckWarningsRequest::setSourceIp(const std::string& sourceIp)
+{
+	sourceIp_ = sourceIp;
+	setParameter("SourceIp", sourceIp);
+}
+
+std::string FixCheckWarningsRequest::getLang()const
+{
+	return lang_;
+}
+
+void FixCheckWarningsRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+
+std::string FixCheckWarningsRequest::getUuids()const
+{
+	return uuids_;
+}
+
+void FixCheckWarningsRequest::setUuids(const std::string& uuids)
+{
+	uuids_ = uuids;
+	setParameter("Uuids", uuids);
+}
+

sas/src/model/FixCheckWarningsResult.cc

@@ -14,35 +14,38 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/sas/model/ModifyAutoDelConfigResult.h>
+#include <alibabacloud/sas/model/FixCheckWarningsResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Sas;
 using namespace AlibabaCloud::Sas::Model;
 
-ModifyAutoDelConfigResult::ModifyAutoDelConfigResult() :
+FixCheckWarningsResult::FixCheckWarningsResult() :
 	ServiceResult()
 {}
 
-ModifyAutoDelConfigResult::ModifyAutoDelConfigResult(const std::string &payload) :
+FixCheckWarningsResult::FixCheckWarningsResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-ModifyAutoDelConfigResult::~ModifyAutoDelConfigResult()
+FixCheckWarningsResult::~FixCheckWarningsResult()
 {}
 
-void ModifyAutoDelConfigResult::parse(const std::string &payload)
+void FixCheckWarningsResult::parse(const std::string &payload)
 {
-	Json::CharReaderBuilder builder;
-	Json::CharReader *reader = builder.newCharReader();
-	Json::Value *val;
+	Json::Reader reader;
 	Json::Value value;
-	JSONCPP_STRING *errs;
-	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
-	value = *val;
+	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	if(!value["BatchId"].isNull())
+		batchId_ = std::stol(value["BatchId"].asString());
 
 }
 
+long FixCheckWarningsResult::getBatchId()const
+{
+	return batchId_;
+}
+

sas/src/model/GetIOCsRequest.cc

@@ -27,6 +27,17 @@ GetIOCsRequest::GetIOCsRequest() :
 GetIOCsRequest::~GetIOCsRequest()
 {}
 
+std::string GetIOCsRequest::getDate()const
+{
+	return date_;
+}
+
+void GetIOCsRequest::setDate(const std::string& date)
+{
+	date_ = date;
+	setParameter("Date", date);
+}
+
 std::string GetIOCsRequest::getType()const
 {
 	return type_;

sas/src/model/ModifyAutoDelConfigRequest.cc

@@ -1,49 +0,0 @@
-/*
- * 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/sas/model/ModifyAutoDelConfigRequest.h>
-
-using AlibabaCloud::Sas::Model::ModifyAutoDelConfigRequest;
-
-ModifyAutoDelConfigRequest::ModifyAutoDelConfigRequest() :
-	RpcServiceRequest("sas", "2018-12-03", "ModifyAutoDelConfig")
-{}
-
-ModifyAutoDelConfigRequest::~ModifyAutoDelConfigRequest()
-{}
-
-std::string ModifyAutoDelConfigRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void ModifyAutoDelConfigRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setCoreParameter("SourceIp", sourceIp);
-}
-
-int ModifyAutoDelConfigRequest::getDays()const
-{
-	return days_;
-}
-
-void ModifyAutoDelConfigRequest::setDays(int days)
-{
-	days_ = days;
-	setCoreParameter("Days", std::to_string(days));
-}
-

sas/src/model/ModifyConcernNecessityRequest.cc

@@ -1,60 +0,0 @@
-/*
- * 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/sas/model/ModifyConcernNecessityRequest.h>
-
-using AlibabaCloud::Sas::Model::ModifyConcernNecessityRequest;
-
-ModifyConcernNecessityRequest::ModifyConcernNecessityRequest() :
-	RpcServiceRequest("sas", "2018-12-03", "ModifyConcernNecessity")
-{}
-
-ModifyConcernNecessityRequest::~ModifyConcernNecessityRequest()
-{}
-
-std::string ModifyConcernNecessityRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void ModifyConcernNecessityRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setCoreParameter("SourceIp", sourceIp);
-}
-
-std::string ModifyConcernNecessityRequest::getLang()const
-{
-	return lang_;
-}
-
-void ModifyConcernNecessityRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setCoreParameter("Lang", lang);
-}
-
-std::string ModifyConcernNecessityRequest::getConcernNecessity()const
-{
-	return concernNecessity_;
-}
-
-void ModifyConcernNecessityRequest::setConcernNecessity(const std::string& concernNecessity)
-{
-	concernNecessity_ = concernNecessity;
-	setCoreParameter("ConcernNecessity", concernNecessity);
-}
-

sas/src/model/ModifyDeleteVulWhitelistRequest.cc

@@ -1,49 +0,0 @@
-/*
- * 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/sas/model/ModifyDeleteVulWhitelistRequest.h>
-
-using AlibabaCloud::Sas::Model::ModifyDeleteVulWhitelistRequest;
-
-ModifyDeleteVulWhitelistRequest::ModifyDeleteVulWhitelistRequest() :
-	RpcServiceRequest("sas", "2018-12-03", "ModifyDeleteVulWhitelist")
-{}
-
-ModifyDeleteVulWhitelistRequest::~ModifyDeleteVulWhitelistRequest()
-{}
-
-std::string ModifyDeleteVulWhitelistRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void ModifyDeleteVulWhitelistRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setCoreParameter("SourceIp", sourceIp);
-}
-
-std::string ModifyDeleteVulWhitelistRequest::getWhitelist()const
-{
-	return whitelist_;
-}
-
-void ModifyDeleteVulWhitelistRequest::setWhitelist(const std::string& whitelist)
-{
-	whitelist_ = whitelist;
-	setCoreParameter("Whitelist", whitelist);
-}
-

sas/src/model/ValidateHcWarningsRequest.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/sas/model/ValidateHcWarningsRequest.h>
+
+using AlibabaCloud::Sas::Model::ValidateHcWarningsRequest;
+
+ValidateHcWarningsRequest::ValidateHcWarningsRequest() :
+	RpcServiceRequest("sas", "2018-12-03", "ValidateHcWarnings")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ValidateHcWarningsRequest::~ValidateHcWarningsRequest()
+{}
+
+std::string ValidateHcWarningsRequest::getRiskIds()const
+{
+	return riskIds_;
+}
+
+void ValidateHcWarningsRequest::setRiskIds(const std::string& riskIds)
+{
+	riskIds_ = riskIds;
+	setParameter("RiskIds", riskIds);
+}
+
+std::string ValidateHcWarningsRequest::getSourceIp()const
+{
+	return sourceIp_;
+}
+
+void ValidateHcWarningsRequest::setSourceIp(const std::string& sourceIp)
+{
+	sourceIp_ = sourceIp;
+	setParameter("SourceIp", sourceIp);
+}
+
+std::string ValidateHcWarningsRequest::getUuids()const
+{
+	return uuids_;
+}
+
+void ValidateHcWarningsRequest::setUuids(const std::string& uuids)
+{
+	uuids_ = uuids;
+	setParameter("Uuids", uuids);
+}
+

sas/src/model/ValidateHcWarningsResult.cc

@@ -14,34 +14,30 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/sas/model/ModifyConcernNecessityResult.h>
+#include <alibabacloud/sas/model/ValidateHcWarningsResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Sas;
 using namespace AlibabaCloud::Sas::Model;
 
-ModifyConcernNecessityResult::ModifyConcernNecessityResult() :
+ValidateHcWarningsResult::ValidateHcWarningsResult() :
 	ServiceResult()
 {}
 
-ModifyConcernNecessityResult::ModifyConcernNecessityResult(const std::string &payload) :
+ValidateHcWarningsResult::ValidateHcWarningsResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-ModifyConcernNecessityResult::~ModifyConcernNecessityResult()
+ValidateHcWarningsResult::~ValidateHcWarningsResult()
 {}
 
-void ModifyConcernNecessityResult::parse(const std::string &payload)
+void ValidateHcWarningsResult::parse(const std::string &payload)
 {
-	Json::CharReaderBuilder builder;
-	Json::CharReader *reader = builder.newCharReader();
-	Json::Value *val;
+	Json::Reader reader;
 	Json::Value value;
-	JSONCPP_STRING *errs;
-	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
-	value = *val;
+	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 
 }

vcs/CMakeLists.txt

@@ -23,51 +23,83 @@ set(vcs_public_header
 set(vcs_public_header_model 
 	include/alibabacloud/vcs/model/AddDeviceRequest.h
 	include/alibabacloud/vcs/model/AddDeviceResult.h
+	include/alibabacloud/vcs/model/AddMonitorRequest.h
+	include/alibabacloud/vcs/model/AddMonitorResult.h
 	include/alibabacloud/vcs/model/CreateCorpRequest.h
 	include/alibabacloud/vcs/model/CreateCorpResult.h
 	include/alibabacloud/vcs/model/DeleteDeviceRequest.h
 	include/alibabacloud/vcs/model/DeleteDeviceResult.h
+	include/alibabacloud/vcs/model/GetBodyOptionsRequest.h
+	include/alibabacloud/vcs/model/GetBodyOptionsResult.h
 	include/alibabacloud/vcs/model/GetDeviceLiveUrlRequest.h
 	include/alibabacloud/vcs/model/GetDeviceLiveUrlResult.h
+	include/alibabacloud/vcs/model/GetDeviceVideoUrlRequest.h
+	include/alibabacloud/vcs/model/GetDeviceVideoUrlResult.h
+	include/alibabacloud/vcs/model/GetFaceOptionsRequest.h
+	include/alibabacloud/vcs/model/GetFaceOptionsResult.h
 	include/alibabacloud/vcs/model/GetInventoryRequest.h
 	include/alibabacloud/vcs/model/GetInventoryResult.h
+	include/alibabacloud/vcs/model/GetMonitorResultRequest.h
+	include/alibabacloud/vcs/model/GetMonitorResultResult.h
 	include/alibabacloud/vcs/model/ListCorpsRequest.h
 	include/alibabacloud/vcs/model/ListCorpsResult.h
 	include/alibabacloud/vcs/model/ListDevicesRequest.h
 	include/alibabacloud/vcs/model/ListDevicesResult.h
 	include/alibabacloud/vcs/model/RecognizeImageRequest.h
 	include/alibabacloud/vcs/model/RecognizeImageResult.h
+	include/alibabacloud/vcs/model/SearchBodyRequest.h
+	include/alibabacloud/vcs/model/SearchBodyResult.h
 	include/alibabacloud/vcs/model/SearchFaceRequest.h
 	include/alibabacloud/vcs/model/SearchFaceResult.h
+	include/alibabacloud/vcs/model/StopMonitorRequest.h
+	include/alibabacloud/vcs/model/StopMonitorResult.h
 	include/alibabacloud/vcs/model/UpdateCorpRequest.h
 	include/alibabacloud/vcs/model/UpdateCorpResult.h
 	include/alibabacloud/vcs/model/UpdateDeviceRequest.h
-	include/alibabacloud/vcs/model/UpdateDeviceResult.h )
+	include/alibabacloud/vcs/model/UpdateDeviceResult.h
+	include/alibabacloud/vcs/model/UpdateMonitorRequest.h
+	include/alibabacloud/vcs/model/UpdateMonitorResult.h )
 
 set(vcs_src 
 	src/VcsClient.cc
 	src/model/AddDeviceRequest.cc
 	src/model/AddDeviceResult.cc
+	src/model/AddMonitorRequest.cc
+	src/model/AddMonitorResult.cc
 	src/model/CreateCorpRequest.cc
 	src/model/CreateCorpResult.cc
 	src/model/DeleteDeviceRequest.cc
 	src/model/DeleteDeviceResult.cc
+	src/model/GetBodyOptionsRequest.cc
+	src/model/GetBodyOptionsResult.cc
 	src/model/GetDeviceLiveUrlRequest.cc
 	src/model/GetDeviceLiveUrlResult.cc
+	src/model/GetDeviceVideoUrlRequest.cc
+	src/model/GetDeviceVideoUrlResult.cc
+	src/model/GetFaceOptionsRequest.cc
+	src/model/GetFaceOptionsResult.cc
 	src/model/GetInventoryRequest.cc
 	src/model/GetInventoryResult.cc
+	src/model/GetMonitorResultRequest.cc
+	src/model/GetMonitorResultResult.cc
 	src/model/ListCorpsRequest.cc
 	src/model/ListCorpsResult.cc
 	src/model/ListDevicesRequest.cc
 	src/model/ListDevicesResult.cc
 	src/model/RecognizeImageRequest.cc
 	src/model/RecognizeImageResult.cc
+	src/model/SearchBodyRequest.cc
+	src/model/SearchBodyResult.cc
 	src/model/SearchFaceRequest.cc
 	src/model/SearchFaceResult.cc
+	src/model/StopMonitorRequest.cc
+	src/model/StopMonitorResult.cc
 	src/model/UpdateCorpRequest.cc
 	src/model/UpdateCorpResult.cc
 	src/model/UpdateDeviceRequest.cc
-	src/model/UpdateDeviceResult.cc )
+	src/model/UpdateDeviceResult.cc
+	src/model/UpdateMonitorRequest.cc
+	src/model/UpdateMonitorResult.cc )
 
 add_library(vcs ${LIB_TYPE}
 	${vcs_public_header}