Add TimeOut.

VERSION

@@ -1 +1 @@
-1.36.1651
+1.36.1663

cbn/include/alibabacloud/cbn/model/DescribeCenInterRegionBandwidthLimitsRequest.h

@@ -36,6 +36,8 @@ public:
 	void setCenId(const std::string &cenId);
 	int getPageNumber() const;
 	void setPageNumber(int pageNumber);
+	std::string getTrRegionId() const;
+	void setTrRegionId(const std::string &trRegionId);
 	int getPageSize() const;
 	void setPageSize(int pageSize);
 	std::string getResourceOwnerAccount() const;
@@ -51,6 +53,7 @@ private:
 	long resourceOwnerId_;
 	std::string cenId_;
 	int pageNumber_;
+	std::string trRegionId_;
 	int pageSize_;
 	std::string resourceOwnerAccount_;
 	std::string ownerAccount_;

cbn/include/alibabacloud/cbn/model/ListTransitRouterMulticastDomainsResult.h

@@ -41,8 +41,10 @@ namespace AlibabaCloud
 					};
 					std::string status;
 					std::string transitRouterMulticastDomainId;
+					std::string cenId;
 					std::string transitRouterMulticastDomainName;
 					std::string transitRouterMulticastDomainDescription;
+					std::string regionId;
 					std::vector<TransitRouterMulticastDomain::Tag> tags;
 					std::string transitRouterId;
 				};

cbn/include/alibabacloud/cbn/model/ListTransitRouterRouteEntriesResult.h

@@ -34,10 +34,21 @@ namespace AlibabaCloud
 			public:
 				struct TransitRouterRouteEntry
 				{
+					struct PathAttributes
+					{
+						std::string originRouteType;
+						int preference;
+						std::string originInstanceType;
+						std::string originInstanceId;
+						std::vector<std::string> communities1;
+						std::vector<std::string> asPaths2;
+					};
 					std::string transitRouterRouteEntryOriginResourceType;
 					std::string transitRouterRouteEntryNextHopId;
 					std::string transitRouterRouteEntryOriginResourceId;
 					std::string prefixListId;
+					std::vector<std::string> communities;
+					PathAttributes pathAttributes;
 					std::string createTime;
 					std::string transitRouterRouteEntryNextHopType;
 					bool operationalMode;
@@ -45,9 +56,11 @@ namespace AlibabaCloud
 					std::string transitRouterRouteEntryNextHopResourceId;
 					std::string transitRouterRouteEntryNextHopResourceType;
 					std::string transitRouterRouteEntryType;
+					int preference;
 					std::string transitRouterRouteEntryDescription;
 					std::string transitRouterRouteEntryName;
 					std::string tag;
+					std::vector<std::string> asPaths;
 					std::string transitRouterRouteEntryId;
 					std::string transitRouterRouteEntryStatus;
 				};

cbn/src/model/DescribeCenInterRegionBandwidthLimitsRequest.cc

@@ -52,6 +52,15 @@ void DescribeCenInterRegionBandwidthLimitsRequest::setPageNumber(int pageNumber)
   setParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
+std::string DescribeCenInterRegionBandwidthLimitsRequest::getTrRegionId() const {
+  return trRegionId_;
+}
+
+void DescribeCenInterRegionBandwidthLimitsRequest::setTrRegionId(const std::string &trRegionId) {
+  trRegionId_ = trRegionId;
+  setParameter(std::string("TrRegionId"), trRegionId);
+}
+
 int DescribeCenInterRegionBandwidthLimitsRequest::getPageSize() const {
   return pageSize_;
 }

cbn/src/model/ListTransitRouterMulticastDomainsResult.cc

@@ -53,6 +53,10 @@ void ListTransitRouterMulticastDomainsResult::parse(const std::string &payload)
 			transitRouterMulticastDomainsObject.status = valueTransitRouterMulticastDomainsTransitRouterMulticastDomain["Status"].asString();
 		if(!valueTransitRouterMulticastDomainsTransitRouterMulticastDomain["TransitRouterId"].isNull())
 			transitRouterMulticastDomainsObject.transitRouterId = valueTransitRouterMulticastDomainsTransitRouterMulticastDomain["TransitRouterId"].asString();
+		if(!valueTransitRouterMulticastDomainsTransitRouterMulticastDomain["RegionId"].isNull())
+			transitRouterMulticastDomainsObject.regionId = valueTransitRouterMulticastDomainsTransitRouterMulticastDomain["RegionId"].asString();
+		if(!valueTransitRouterMulticastDomainsTransitRouterMulticastDomain["CenId"].isNull())
+			transitRouterMulticastDomainsObject.cenId = valueTransitRouterMulticastDomainsTransitRouterMulticastDomain["CenId"].asString();
 		auto allTagsNode = valueTransitRouterMulticastDomainsTransitRouterMulticastDomain["Tags"]["Tag"];
 		for (auto valueTransitRouterMulticastDomainsTransitRouterMulticastDomainTagsTag : allTagsNode)
 		{

cbn/src/model/ListTransitRouterRouteEntriesResult.cc

@@ -75,6 +75,29 @@ void ListTransitRouterRouteEntriesResult::parse(const std::string &payload)
 			transitRouterRouteEntriesObject.transitRouterRouteEntryOriginResourceId = valueTransitRouterRouteEntriesTransitRouterRouteEntry["TransitRouterRouteEntryOriginResourceId"].asString();
 		if(!valueTransitRouterRouteEntriesTransitRouterRouteEntry["PrefixListId"].isNull())
 			transitRouterRouteEntriesObject.prefixListId = valueTransitRouterRouteEntriesTransitRouterRouteEntry["PrefixListId"].asString();
+		if(!valueTransitRouterRouteEntriesTransitRouterRouteEntry["Preference"].isNull())
+			transitRouterRouteEntriesObject.preference = std::stoi(valueTransitRouterRouteEntriesTransitRouterRouteEntry["Preference"].asString());
+		auto pathAttributesNode = value["PathAttributes"];
+		if(!pathAttributesNode["OriginInstanceId"].isNull())
+			transitRouterRouteEntriesObject.pathAttributes.originInstanceId = pathAttributesNode["OriginInstanceId"].asString();
+		if(!pathAttributesNode["OriginInstanceType"].isNull())
+			transitRouterRouteEntriesObject.pathAttributes.originInstanceType = pathAttributesNode["OriginInstanceType"].asString();
+		if(!pathAttributesNode["OriginRouteType"].isNull())
+			transitRouterRouteEntriesObject.pathAttributes.originRouteType = pathAttributesNode["OriginRouteType"].asString();
+		if(!pathAttributesNode["Preference"].isNull())
+			transitRouterRouteEntriesObject.pathAttributes.preference = std::stoi(pathAttributesNode["Preference"].asString());
+			auto allCommunities1 = pathAttributesNode["Communities"]["Community"];
+			for (auto value : allCommunities1)
+				transitRouterRouteEntriesObject.pathAttributes.communities1.push_back(value.asString());
+			auto allAsPaths2 = pathAttributesNode["AsPaths"]["AsPath"];
+			for (auto value : allAsPaths2)
+				transitRouterRouteEntriesObject.pathAttributes.asPaths2.push_back(value.asString());
+		auto allCommunities = value["Communities"]["Community"];
+		for (auto value : allCommunities)
+			transitRouterRouteEntriesObject.communities.push_back(value.asString());
+		auto allAsPaths = value["AsPaths"]["AsPath"];
+		for (auto value : allAsPaths)
+			transitRouterRouteEntriesObject.asPaths.push_back(value.asString());
 		transitRouterRouteEntries_.push_back(transitRouterRouteEntriesObject);
 	}
 	if(!value["NextToken"].isNull())

dataworks-public/CMakeLists.txt

@@ -89,6 +89,8 @@ set(dataworks-public_public_header_model
 	include/alibabacloud/dataworks-public/model/CreateQualityRuleResult.h
 	include/alibabacloud/dataworks-public/model/CreateRemindRequest.h
 	include/alibabacloud/dataworks-public/model/CreateRemindResult.h
+	include/alibabacloud/dataworks-public/model/CreateResourceFileRequest.h
+	include/alibabacloud/dataworks-public/model/CreateResourceFileResult.h
 	include/alibabacloud/dataworks-public/model/CreateTableRequest.h
 	include/alibabacloud/dataworks-public/model/CreateTableResult.h
 	include/alibabacloud/dataworks-public/model/CreateTableLevelRequest.h
@@ -604,6 +606,8 @@ set(dataworks-public_src
 	src/model/CreateQualityRuleResult.cc
 	src/model/CreateRemindRequest.cc
 	src/model/CreateRemindResult.cc
+	src/model/CreateResourceFileRequest.cc
+	src/model/CreateResourceFileResult.cc
 	src/model/CreateTableRequest.cc
 	src/model/CreateTableResult.cc
 	src/model/CreateTableLevelRequest.cc

dataworks-public/include/alibabacloud/dataworks-public/Dataworks_publicClient.h

@@ -90,6 +90,8 @@
 #include "model/CreateQualityRuleResult.h"
 #include "model/CreateRemindRequest.h"
 #include "model/CreateRemindResult.h"
+#include "model/CreateResourceFileRequest.h"
+#include "model/CreateResourceFileResult.h"
 #include "model/CreateTableRequest.h"
 #include "model/CreateTableResult.h"
 #include "model/CreateTableLevelRequest.h"
@@ -645,6 +647,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateRemindResult> CreateRemindOutcome;
 			typedef std::future<CreateRemindOutcome> CreateRemindOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateRemindRequest&, const CreateRemindOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRemindAsyncHandler;
+			typedef Outcome<Error, Model::CreateResourceFileResult> CreateResourceFileOutcome;
+			typedef std::future<CreateResourceFileOutcome> CreateResourceFileOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateResourceFileRequest&, const CreateResourceFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateResourceFileAsyncHandler;
 			typedef Outcome<Error, Model::CreateTableResult> CreateTableOutcome;
 			typedef std::future<CreateTableOutcome> CreateTableOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateTableRequest&, const CreateTableOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTableAsyncHandler;
@@ -1418,6 +1423,9 @@ namespace AlibabaCloud
 			CreateRemindOutcome createRemind(const Model::CreateRemindRequest &request)const;
 			void createRemindAsync(const Model::CreateRemindRequest& request, const CreateRemindAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateRemindOutcomeCallable createRemindCallable(const Model::CreateRemindRequest& request) const;
+			CreateResourceFileOutcome createResourceFile(const Model::CreateResourceFileRequest &request)const;
+			void createResourceFileAsync(const Model::CreateResourceFileRequest& request, const CreateResourceFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateResourceFileOutcomeCallable createResourceFileCallable(const Model::CreateResourceFileRequest& request) const;
 			CreateTableOutcome createTable(const Model::CreateTableRequest &request)const;
 			void createTableAsync(const Model::CreateTableRequest& request, const CreateTableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateTableOutcomeCallable createTableCallable(const Model::CreateTableRequest& request) const;

dataworks-public/include/alibabacloud/dataworks-public/model/CreateFileRequest.h

@@ -56,6 +56,8 @@ public:
 	void setAutoRerunIntervalMillis(int autoRerunIntervalMillis);
 	std::string getInputList() const;
 	void setInputList(const std::string &inputList);
+	bool getCreateFolderIfNotExists() const;
+	void setCreateFolderIfNotExists(bool createFolderIfNotExists);
 	std::string getRerunMode() const;
 	void setRerunMode(const std::string &rerunMode);
 	std::string getConnectionName() const;
@@ -105,6 +107,7 @@ private:
 	std::string owner_;
 	int autoRerunIntervalMillis_;
 	std::string inputList_;
+	bool createFolderIfNotExists_;
 	std::string rerunMode_;
 	std::string connectionName_;
 	std::string outputParameters_;

dataworks-public/include/alibabacloud/dataworks-public/model/CreateResourceFileRequest.h

@@ -0,0 +1,75 @@
+/*
+ * 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_DATAWORKS_PUBLIC_MODEL_CREATERESOURCEFILEREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATERESOURCEFILEREQUEST_H_
+
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Dataworks_public {
+namespace Model {
+class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateResourceFileRequest : public RpcServiceRequest {
+public:
+	CreateResourceFileRequest();
+	~CreateResourceFileRequest();
+	int getFileType() const;
+	void setFileType(int fileType);
+	std::string getContent() const;
+	void setContent(const std::string &content);
+	std::string getResourceFile() const;
+	void setResourceFile(const std::string &resourceFile);
+	std::string getOriginResourceName() const;
+	void setOriginResourceName(const std::string &originResourceName);
+	long getProjectId() const;
+	void setProjectId(long projectId);
+	std::string getStorageURL() const;
+	void setStorageURL(const std::string &storageURL);
+	std::string getOwner() const;
+	void setOwner(const std::string &owner);
+	bool getRegisterToCalcEngine() const;
+	void setRegisterToCalcEngine(bool registerToCalcEngine);
+	bool getUploadMode() const;
+	void setUploadMode(bool uploadMode);
+	std::string getFileName() const;
+	void setFileName(const std::string &fileName);
+	std::string getFileFolderPath() const;
+	void setFileFolderPath(const std::string &fileFolderPath);
+	std::string getFileDescription() const;
+	void setFileDescription(const std::string &fileDescription);
+
+private:
+	int fileType_;
+	std::string content_;
+	std::string resourceFile_;
+	std::string originResourceName_;
+	long projectId_;
+	std::string storageURL_;
+	std::string owner_;
+	bool registerToCalcEngine_;
+	bool uploadMode_;
+	std::string fileName_;
+	std::string fileFolderPath_;
+	std::string fileDescription_;
+};
+} // namespace Model
+} // namespace Dataworks_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATERESOURCEFILEREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateResourceFileResult.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_DATAWORKS_PUBLIC_MODEL_CREATERESOURCEFILERESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATERESOURCEFILERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateResourceFileResult : public ServiceResult
+			{
+			public:
+
+
+				CreateResourceFileResult();
+				explicit CreateResourceFileResult(const std::string &payload);
+				~CreateResourceFileResult();
+				long getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATERESOURCEFILERESULT_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateUdfFileRequest.h

@@ -30,6 +30,8 @@ class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateUdfFileRequest : public RpcServ
 public:
 	CreateUdfFileRequest();
 	~CreateUdfFileRequest();
+	bool getCreateFolderIfNotExists() const;
+	void setCreateFolderIfNotExists(bool createFolderIfNotExists);
 	std::string getReturnValue() const;
 	void setReturnValue(const std::string &returnValue);
 	std::string getResources() const;
@@ -56,6 +58,7 @@ public:
 	void setProjectId(long projectId);
 
 private:
+	bool createFolderIfNotExists_;
 	std::string returnValue_;
 	std::string resources_;
 	std::string functionType_;

dataworks-public/include/alibabacloud/dataworks-public/model/ListFilesRequest.h

@@ -34,14 +34,22 @@ public:
 	void setOwner(const std::string &owner);
 	std::string getFileTypes() const;
 	void setFileTypes(const std::string &fileTypes);
+	bool getNeedContent() const;
+	void setNeedContent(bool needContent);
+	bool getNeedAbsoluteFolderPath() const;
+	void setNeedAbsoluteFolderPath(bool needAbsoluteFolderPath);
 	std::string getProjectIdentifier() const;
 	void setProjectIdentifier(const std::string &projectIdentifier);
 	int getPageNumber() const;
 	void setPageNumber(int pageNumber);
+	std::string getFileIdIn() const;
+	void setFileIdIn(const std::string &fileIdIn);
 	std::string getFileFolderPath() const;
 	void setFileFolderPath(const std::string &fileFolderPath);
 	int getPageSize() const;
 	void setPageSize(int pageSize);
+	std::string getExactFileName() const;
+	void setExactFileName(const std::string &exactFileName);
 	std::string getKeyword() const;
 	void setKeyword(const std::string &keyword);
 	long getProjectId() const;
@@ -54,10 +62,14 @@ public:
 private:
 	std::string owner_;
 	std::string fileTypes_;
+	bool needContent_;
+	bool needAbsoluteFolderPath_;
 	std::string projectIdentifier_;
 	int pageNumber_;
+	std::string fileIdIn_;
 	std::string fileFolderPath_;
 	int pageSize_;
+	std::string exactFileName_;
 	std::string keyword_;
 	long projectId_;
 	std::string useType_;

dataworks-public/include/alibabacloud/dataworks-public/model/ListFilesResult.h

@@ -50,6 +50,7 @@ namespace AlibabaCloud
 						int fileType;
 						std::string lastEditUser;
 						std::string content;
+						std::string absoluteFolderPath;
 						int commitStatus;
 						long nodeId;
 						bool autoParsing;

dataworks-public/src/Dataworks-publicClient.cc

@@ -1275,6 +1275,42 @@ Dataworks_publicClient::CreateRemindOutcomeCallable Dataworks_publicClient::crea
 	return task->get_future();
 }
 
+Dataworks_publicClient::CreateResourceFileOutcome Dataworks_publicClient::createResourceFile(const CreateResourceFileRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateResourceFileOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateResourceFileOutcome(CreateResourceFileResult(outcome.result()));
+	else
+		return CreateResourceFileOutcome(outcome.error());
+}
+
+void Dataworks_publicClient::createResourceFileAsync(const CreateResourceFileRequest& request, const CreateResourceFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createResourceFile(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dataworks_publicClient::CreateResourceFileOutcomeCallable Dataworks_publicClient::createResourceFileCallable(const CreateResourceFileRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateResourceFileOutcome()>>(
+			[this, request]()
+			{
+			return this->createResourceFile(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dataworks_publicClient::CreateTableOutcome Dataworks_publicClient::createTable(const CreateTableRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

dataworks-public/src/model/CreateFileRequest.cc

@@ -142,6 +142,15 @@ void CreateFileRequest::setInputList(const std::string &inputList) {
   setBodyParameter(std::string("InputList"), inputList);
 }
 
+bool CreateFileRequest::getCreateFolderIfNotExists() const {
+  return createFolderIfNotExists_;
+}
+
+void CreateFileRequest::setCreateFolderIfNotExists(bool createFolderIfNotExists) {
+  createFolderIfNotExists_ = createFolderIfNotExists;
+  setBodyParameter(std::string("CreateFolderIfNotExists"), createFolderIfNotExists ? "true" : "false");
+}
+
 std::string CreateFileRequest::getRerunMode() const {
   return rerunMode_;
 }

dataworks-public/src/model/CreateResourceFileRequest.cc

@@ -0,0 +1,135 @@
+/*
+ * 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/dataworks-public/model/CreateResourceFileRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::CreateResourceFileRequest;
+
+CreateResourceFileRequest::CreateResourceFileRequest()
+    : RpcServiceRequest("dataworks-public", "2020-05-18", "CreateResourceFile") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateResourceFileRequest::~CreateResourceFileRequest() {}
+
+int CreateResourceFileRequest::getFileType() const {
+  return fileType_;
+}
+
+void CreateResourceFileRequest::setFileType(int fileType) {
+  fileType_ = fileType;
+  setBodyParameter(std::string("FileType"), std::to_string(fileType));
+}
+
+std::string CreateResourceFileRequest::getContent() const {
+  return content_;
+}
+
+void CreateResourceFileRequest::setContent(const std::string &content) {
+  content_ = content;
+  setBodyParameter(std::string("Content"), content);
+}
+
+std::string CreateResourceFileRequest::getResourceFile() const {
+  return resourceFile_;
+}
+
+void CreateResourceFileRequest::setResourceFile(const std::string &resourceFile) {
+  resourceFile_ = resourceFile;
+  setBodyParameter(std::string("ResourceFile"), resourceFile);
+}
+
+std::string CreateResourceFileRequest::getOriginResourceName() const {
+  return originResourceName_;
+}
+
+void CreateResourceFileRequest::setOriginResourceName(const std::string &originResourceName) {
+  originResourceName_ = originResourceName;
+  setBodyParameter(std::string("OriginResourceName"), originResourceName);
+}
+
+long CreateResourceFileRequest::getProjectId() const {
+  return projectId_;
+}
+
+void CreateResourceFileRequest::setProjectId(long projectId) {
+  projectId_ = projectId;
+  setBodyParameter(std::string("ProjectId"), std::to_string(projectId));
+}
+
+std::string CreateResourceFileRequest::getStorageURL() const {
+  return storageURL_;
+}
+
+void CreateResourceFileRequest::setStorageURL(const std::string &storageURL) {
+  storageURL_ = storageURL;
+  setBodyParameter(std::string("StorageURL"), storageURL);
+}
+
+std::string CreateResourceFileRequest::getOwner() const {
+  return owner_;
+}
+
+void CreateResourceFileRequest::setOwner(const std::string &owner) {
+  owner_ = owner;
+  setBodyParameter(std::string("Owner"), owner);
+}
+
+bool CreateResourceFileRequest::getRegisterToCalcEngine() const {
+  return registerToCalcEngine_;
+}
+
+void CreateResourceFileRequest::setRegisterToCalcEngine(bool registerToCalcEngine) {
+  registerToCalcEngine_ = registerToCalcEngine;
+  setBodyParameter(std::string("RegisterToCalcEngine"), registerToCalcEngine ? "true" : "false");
+}
+
+bool CreateResourceFileRequest::getUploadMode() const {
+  return uploadMode_;
+}
+
+void CreateResourceFileRequest::setUploadMode(bool uploadMode) {
+  uploadMode_ = uploadMode;
+  setBodyParameter(std::string("UploadMode"), uploadMode ? "true" : "false");
+}
+
+std::string CreateResourceFileRequest::getFileName() const {
+  return fileName_;
+}
+
+void CreateResourceFileRequest::setFileName(const std::string &fileName) {
+  fileName_ = fileName;
+  setBodyParameter(std::string("FileName"), fileName);
+}
+
+std::string CreateResourceFileRequest::getFileFolderPath() const {
+  return fileFolderPath_;
+}
+
+void CreateResourceFileRequest::setFileFolderPath(const std::string &fileFolderPath) {
+  fileFolderPath_ = fileFolderPath;
+  setBodyParameter(std::string("FileFolderPath"), fileFolderPath);
+}
+
+std::string CreateResourceFileRequest::getFileDescription() const {
+  return fileDescription_;
+}
+
+void CreateResourceFileRequest::setFileDescription(const std::string &fileDescription) {
+  fileDescription_ = fileDescription;
+  setBodyParameter(std::string("FileDescription"), fileDescription);
+}
+

dataworks-public/src/model/CreateResourceFileResult.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/dataworks-public/model/CreateResourceFileResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dataworks_public;
+using namespace AlibabaCloud::Dataworks_public::Model;
+
+CreateResourceFileResult::CreateResourceFileResult() :
+	ServiceResult()
+{}
+
+CreateResourceFileResult::CreateResourceFileResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateResourceFileResult::~CreateResourceFileResult()
+{}
+
+void CreateResourceFileResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Data"].isNull())
+		data_ = std::stol(value["Data"].asString());
+
+}
+
+long CreateResourceFileResult::getData()const
+{
+	return data_;
+}
+

dataworks-public/src/model/CreateUdfFileRequest.cc

@@ -25,6 +25,15 @@ CreateUdfFileRequest::CreateUdfFileRequest()
 
 CreateUdfFileRequest::~CreateUdfFileRequest() {}
 
+bool CreateUdfFileRequest::getCreateFolderIfNotExists() const {
+  return createFolderIfNotExists_;
+}
+
+void CreateUdfFileRequest::setCreateFolderIfNotExists(bool createFolderIfNotExists) {
+  createFolderIfNotExists_ = createFolderIfNotExists;
+  setBodyParameter(std::string("CreateFolderIfNotExists"), createFolderIfNotExists ? "true" : "false");
+}
+
 std::string CreateUdfFileRequest::getReturnValue() const {
   return returnValue_;
 }

dataworks-public/src/model/ListFilesRequest.cc

@@ -43,6 +43,24 @@ void ListFilesRequest::setFileTypes(const std::string &fileTypes) {
   setBodyParameter(std::string("FileTypes"), fileTypes);
 }
 
+bool ListFilesRequest::getNeedContent() const {
+  return needContent_;
+}
+
+void ListFilesRequest::setNeedContent(bool needContent) {
+  needContent_ = needContent;
+  setBodyParameter(std::string("NeedContent"), needContent ? "true" : "false");
+}
+
+bool ListFilesRequest::getNeedAbsoluteFolderPath() const {
+  return needAbsoluteFolderPath_;
+}
+
+void ListFilesRequest::setNeedAbsoluteFolderPath(bool needAbsoluteFolderPath) {
+  needAbsoluteFolderPath_ = needAbsoluteFolderPath;
+  setBodyParameter(std::string("NeedAbsoluteFolderPath"), needAbsoluteFolderPath ? "true" : "false");
+}
+
 std::string ListFilesRequest::getProjectIdentifier() const {
   return projectIdentifier_;
 }
@@ -61,6 +79,15 @@ void ListFilesRequest::setPageNumber(int pageNumber) {
   setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
+std::string ListFilesRequest::getFileIdIn() const {
+  return fileIdIn_;
+}
+
+void ListFilesRequest::setFileIdIn(const std::string &fileIdIn) {
+  fileIdIn_ = fileIdIn;
+  setBodyParameter(std::string("FileIdIn"), fileIdIn);
+}
+
 std::string ListFilesRequest::getFileFolderPath() const {
   return fileFolderPath_;
 }
@@ -79,6 +106,15 @@ void ListFilesRequest::setPageSize(int pageSize) {
   setBodyParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
+std::string ListFilesRequest::getExactFileName() const {
+  return exactFileName_;
+}
+
+void ListFilesRequest::setExactFileName(const std::string &exactFileName) {
+  exactFileName_ = exactFileName;
+  setBodyParameter(std::string("ExactFileName"), exactFileName);
+}
+
 std::string ListFilesRequest::getKeyword() const {
   return keyword_;
 }

dataworks-public/src/model/ListFilesResult.cc

@@ -92,6 +92,8 @@ void ListFilesResult::parse(const std::string &payload)
 			fileObject.content = dataNodeFilesFile["Content"].asString();
 		if(!dataNodeFilesFile["NodeId"].isNull())
 			fileObject.nodeId = std::stol(dataNodeFilesFile["NodeId"].asString());
+		if(!dataNodeFilesFile["AbsoluteFolderPath"].isNull())
+			fileObject.absoluteFolderPath = dataNodeFilesFile["AbsoluteFolderPath"].asString();
 		data_.files.push_back(fileObject);
 	}
 	if(!value["HttpStatusCode"].isNull())

ehpc/CMakeLists.txt

@@ -103,6 +103,8 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/DescribeNFSClientStatusResult.h
 	include/alibabacloud/ehpc/model/DescribePriceRequest.h
 	include/alibabacloud/ehpc/model/DescribePriceResult.h
+	include/alibabacloud/ehpc/model/DescribeServerlessJobsRequest.h
+	include/alibabacloud/ehpc/model/DescribeServerlessJobsResult.h
 	include/alibabacloud/ehpc/model/EditJobTemplateRequest.h
 	include/alibabacloud/ehpc/model/EditJobTemplateResult.h
 	include/alibabacloud/ehpc/model/GetAccountingReportRequest.h
@@ -195,6 +197,8 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/ListRegionsResult.h
 	include/alibabacloud/ehpc/model/ListSecurityGroupsRequest.h
 	include/alibabacloud/ehpc/model/ListSecurityGroupsResult.h
+	include/alibabacloud/ehpc/model/ListServerlessJobsRequest.h
+	include/alibabacloud/ehpc/model/ListServerlessJobsResult.h
 	include/alibabacloud/ehpc/model/ListSoftwaresRequest.h
 	include/alibabacloud/ehpc/model/ListSoftwaresResult.h
 	include/alibabacloud/ehpc/model/ListTagResourcesRequest.h
@@ -265,10 +269,14 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/StopJobsResult.h
 	include/alibabacloud/ehpc/model/StopNodesRequest.h
 	include/alibabacloud/ehpc/model/StopNodesResult.h
+	include/alibabacloud/ehpc/model/StopServerlessJobsRequest.h
+	include/alibabacloud/ehpc/model/StopServerlessJobsResult.h
 	include/alibabacloud/ehpc/model/StopVisualServiceRequest.h
 	include/alibabacloud/ehpc/model/StopVisualServiceResult.h
 	include/alibabacloud/ehpc/model/SubmitJobRequest.h
 	include/alibabacloud/ehpc/model/SubmitJobResult.h
+	include/alibabacloud/ehpc/model/SubmitServerlessJobRequest.h
+	include/alibabacloud/ehpc/model/SubmitServerlessJobResult.h
 	include/alibabacloud/ehpc/model/SummaryImagesRequest.h
 	include/alibabacloud/ehpc/model/SummaryImagesResult.h
 	include/alibabacloud/ehpc/model/SummaryImagesInfoRequest.h
@@ -372,6 +380,8 @@ set(ehpc_src
 	src/model/DescribeNFSClientStatusResult.cc
 	src/model/DescribePriceRequest.cc
 	src/model/DescribePriceResult.cc
+	src/model/DescribeServerlessJobsRequest.cc
+	src/model/DescribeServerlessJobsResult.cc
 	src/model/EditJobTemplateRequest.cc
 	src/model/EditJobTemplateResult.cc
 	src/model/GetAccountingReportRequest.cc
@@ -464,6 +474,8 @@ set(ehpc_src
 	src/model/ListRegionsResult.cc
 	src/model/ListSecurityGroupsRequest.cc
 	src/model/ListSecurityGroupsResult.cc
+	src/model/ListServerlessJobsRequest.cc
+	src/model/ListServerlessJobsResult.cc
 	src/model/ListSoftwaresRequest.cc
 	src/model/ListSoftwaresResult.cc
 	src/model/ListTagResourcesRequest.cc
@@ -534,10 +546,14 @@ set(ehpc_src
 	src/model/StopJobsResult.cc
 	src/model/StopNodesRequest.cc
 	src/model/StopNodesResult.cc
+	src/model/StopServerlessJobsRequest.cc
+	src/model/StopServerlessJobsResult.cc
 	src/model/StopVisualServiceRequest.cc
 	src/model/StopVisualServiceResult.cc
 	src/model/SubmitJobRequest.cc
 	src/model/SubmitJobResult.cc
+	src/model/SubmitServerlessJobRequest.cc
+	src/model/SubmitServerlessJobResult.cc
 	src/model/SummaryImagesRequest.cc
 	src/model/SummaryImagesResult.cc
 	src/model/SummaryImagesInfoRequest.cc

ehpc/include/alibabacloud/ehpc/EHPCClient.h

@@ -104,6 +104,8 @@
 #include "model/DescribeNFSClientStatusResult.h"
 #include "model/DescribePriceRequest.h"
 #include "model/DescribePriceResult.h"
+#include "model/DescribeServerlessJobsRequest.h"
+#include "model/DescribeServerlessJobsResult.h"
 #include "model/EditJobTemplateRequest.h"
 #include "model/EditJobTemplateResult.h"
 #include "model/GetAccountingReportRequest.h"
@@ -196,6 +198,8 @@
 #include "model/ListRegionsResult.h"
 #include "model/ListSecurityGroupsRequest.h"
 #include "model/ListSecurityGroupsResult.h"
+#include "model/ListServerlessJobsRequest.h"
+#include "model/ListServerlessJobsResult.h"
 #include "model/ListSoftwaresRequest.h"
 #include "model/ListSoftwaresResult.h"
 #include "model/ListTagResourcesRequest.h"
@@ -266,10 +270,14 @@
 #include "model/StopJobsResult.h"
 #include "model/StopNodesRequest.h"
 #include "model/StopNodesResult.h"
+#include "model/StopServerlessJobsRequest.h"
+#include "model/StopServerlessJobsResult.h"
 #include "model/StopVisualServiceRequest.h"
 #include "model/StopVisualServiceResult.h"
 #include "model/SubmitJobRequest.h"
 #include "model/SubmitJobResult.h"
+#include "model/SubmitServerlessJobRequest.h"
+#include "model/SubmitServerlessJobResult.h"
 #include "model/SummaryImagesRequest.h"
 #include "model/SummaryImagesResult.h"
 #include "model/SummaryImagesInfoRequest.h"
@@ -420,6 +428,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribePriceResult> DescribePriceOutcome;
 			typedef std::future<DescribePriceOutcome> DescribePriceOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::DescribePriceRequest&, const DescribePriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePriceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeServerlessJobsResult> DescribeServerlessJobsOutcome;
+			typedef std::future<DescribeServerlessJobsOutcome> DescribeServerlessJobsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeServerlessJobsRequest&, const DescribeServerlessJobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeServerlessJobsAsyncHandler;
 			typedef Outcome<Error, Model::EditJobTemplateResult> EditJobTemplateOutcome;
 			typedef std::future<EditJobTemplateOutcome> EditJobTemplateOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::EditJobTemplateRequest&, const EditJobTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EditJobTemplateAsyncHandler;
@@ -558,6 +569,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListSecurityGroupsResult> ListSecurityGroupsOutcome;
 			typedef std::future<ListSecurityGroupsOutcome> ListSecurityGroupsOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListSecurityGroupsRequest&, const ListSecurityGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSecurityGroupsAsyncHandler;
+			typedef Outcome<Error, Model::ListServerlessJobsResult> ListServerlessJobsOutcome;
+			typedef std::future<ListServerlessJobsOutcome> ListServerlessJobsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListServerlessJobsRequest&, const ListServerlessJobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListServerlessJobsAsyncHandler;
 			typedef Outcome<Error, Model::ListSoftwaresResult> ListSoftwaresOutcome;
 			typedef std::future<ListSoftwaresOutcome> ListSoftwaresOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListSoftwaresRequest&, const ListSoftwaresOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSoftwaresAsyncHandler;
@@ -663,12 +677,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::StopNodesResult> StopNodesOutcome;
 			typedef std::future<StopNodesOutcome> StopNodesOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::StopNodesRequest&, const StopNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopNodesAsyncHandler;
+			typedef Outcome<Error, Model::StopServerlessJobsResult> StopServerlessJobsOutcome;
+			typedef std::future<StopServerlessJobsOutcome> StopServerlessJobsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::StopServerlessJobsRequest&, const StopServerlessJobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopServerlessJobsAsyncHandler;
 			typedef Outcome<Error, Model::StopVisualServiceResult> StopVisualServiceOutcome;
 			typedef std::future<StopVisualServiceOutcome> StopVisualServiceOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::StopVisualServiceRequest&, const StopVisualServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopVisualServiceAsyncHandler;
 			typedef Outcome<Error, Model::SubmitJobResult> SubmitJobOutcome;
 			typedef std::future<SubmitJobOutcome> SubmitJobOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::SubmitJobRequest&, const SubmitJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SubmitJobAsyncHandler;
+			typedef Outcome<Error, Model::SubmitServerlessJobResult> SubmitServerlessJobOutcome;
+			typedef std::future<SubmitServerlessJobOutcome> SubmitServerlessJobOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::SubmitServerlessJobRequest&, const SubmitServerlessJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SubmitServerlessJobAsyncHandler;
 			typedef Outcome<Error, Model::SummaryImagesResult> SummaryImagesOutcome;
 			typedef std::future<SummaryImagesOutcome> SummaryImagesOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::SummaryImagesRequest&, const SummaryImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SummaryImagesAsyncHandler;
@@ -824,6 +844,9 @@ namespace AlibabaCloud
 			DescribePriceOutcome describePrice(const Model::DescribePriceRequest &request)const;
 			void describePriceAsync(const Model::DescribePriceRequest& request, const DescribePriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribePriceOutcomeCallable describePriceCallable(const Model::DescribePriceRequest& request) const;
+			DescribeServerlessJobsOutcome describeServerlessJobs(const Model::DescribeServerlessJobsRequest &request)const;
+			void describeServerlessJobsAsync(const Model::DescribeServerlessJobsRequest& request, const DescribeServerlessJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeServerlessJobsOutcomeCallable describeServerlessJobsCallable(const Model::DescribeServerlessJobsRequest& request) const;
 			EditJobTemplateOutcome editJobTemplate(const Model::EditJobTemplateRequest &request)const;
 			void editJobTemplateAsync(const Model::EditJobTemplateRequest& request, const EditJobTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EditJobTemplateOutcomeCallable editJobTemplateCallable(const Model::EditJobTemplateRequest& request) const;
@@ -962,6 +985,9 @@ namespace AlibabaCloud
 			ListSecurityGroupsOutcome listSecurityGroups(const Model::ListSecurityGroupsRequest &request)const;
 			void listSecurityGroupsAsync(const Model::ListSecurityGroupsRequest& request, const ListSecurityGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListSecurityGroupsOutcomeCallable listSecurityGroupsCallable(const Model::ListSecurityGroupsRequest& request) const;
+			ListServerlessJobsOutcome listServerlessJobs(const Model::ListServerlessJobsRequest &request)const;
+			void listServerlessJobsAsync(const Model::ListServerlessJobsRequest& request, const ListServerlessJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListServerlessJobsOutcomeCallable listServerlessJobsCallable(const Model::ListServerlessJobsRequest& request) const;
 			ListSoftwaresOutcome listSoftwares(const Model::ListSoftwaresRequest &request)const;
 			void listSoftwaresAsync(const Model::ListSoftwaresRequest& request, const ListSoftwaresAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListSoftwaresOutcomeCallable listSoftwaresCallable(const Model::ListSoftwaresRequest& request) const;
@@ -1067,12 +1093,18 @@ namespace AlibabaCloud
 			StopNodesOutcome stopNodes(const Model::StopNodesRequest &request)const;
 			void stopNodesAsync(const Model::StopNodesRequest& request, const StopNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StopNodesOutcomeCallable stopNodesCallable(const Model::StopNodesRequest& request) const;
+			StopServerlessJobsOutcome stopServerlessJobs(const Model::StopServerlessJobsRequest &request)const;
+			void stopServerlessJobsAsync(const Model::StopServerlessJobsRequest& request, const StopServerlessJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopServerlessJobsOutcomeCallable stopServerlessJobsCallable(const Model::StopServerlessJobsRequest& request) const;
 			StopVisualServiceOutcome stopVisualService(const Model::StopVisualServiceRequest &request)const;
 			void stopVisualServiceAsync(const Model::StopVisualServiceRequest& request, const StopVisualServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StopVisualServiceOutcomeCallable stopVisualServiceCallable(const Model::StopVisualServiceRequest& request) const;
 			SubmitJobOutcome submitJob(const Model::SubmitJobRequest &request)const;
 			void submitJobAsync(const Model::SubmitJobRequest& request, const SubmitJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SubmitJobOutcomeCallable submitJobCallable(const Model::SubmitJobRequest& request) const;
+			SubmitServerlessJobOutcome submitServerlessJob(const Model::SubmitServerlessJobRequest &request)const;
+			void submitServerlessJobAsync(const Model::SubmitServerlessJobRequest& request, const SubmitServerlessJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SubmitServerlessJobOutcomeCallable submitServerlessJobCallable(const Model::SubmitServerlessJobRequest& request) const;
 			SummaryImagesOutcome summaryImages(const Model::SummaryImagesRequest &request)const;
 			void summaryImagesAsync(const Model::SummaryImagesRequest& request, const SummaryImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SummaryImagesOutcomeCallable summaryImagesCallable(const Model::SummaryImagesRequest& request) const;

ehpc/include/alibabacloud/ehpc/model/AddNodesRequest.h

@@ -38,6 +38,48 @@ public:
 	};
 	AddNodesRequest();
 	~AddNodesRequest();
+	std::string getDnsConfig() const;
+	void setDnsConfig(const std::string &dnsConfig);
+	std::string getImageOwnerAlias() const;
+	void setImageOwnerAlias(const std::string &imageOwnerAlias);
+	std::vector<DataDisks> getDataDisks() const;
+	void setDataDisks(const std::vector<DataDisks> &dataDisks);
+	int getSystemDiskSize() const;
+	void setSystemDiskSize(int systemDiskSize);
+	std::string getHostNamePrefix() const;
+	void setHostNamePrefix(const std::string &hostNamePrefix);
+	std::string getComputeSpotInterruptionBehavior() const;
+	void setComputeSpotInterruptionBehavior(const std::string &computeSpotInterruptionBehavior);
+	std::string getComputeSpotPriceLimit() const;
+	void setComputeSpotPriceLimit(const std::string &computeSpotPriceLimit);
+	int getAutoRenewPeriod() const;
+	void setAutoRenewPeriod(int autoRenewPeriod);
+	int getPeriod() const;
+	void setPeriod(int period);
+	int getCount() const;
+	void setCount(int count);
+	std::string getComputeSpotStrategy() const;
+	void setComputeSpotStrategy(const std::string &computeSpotStrategy);
+	std::string getHostNameSuffix() const;
+	void setHostNameSuffix(const std::string &hostNameSuffix);
+	bool getSync() const;
+	void setSync(bool sync);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
+	std::string getPeriodUnit() const;
+	void setPeriodUnit(const std::string &periodUnit);
+	bool getComputeEnableHt() const;
+	void setComputeEnableHt(bool computeEnableHt);
+	std::string getAutoRenew() const;
+	void setAutoRenew(const std::string &autoRenew);
+	std::string getInternetChargeType() const;
+	void setInternetChargeType(const std::string &internetChargeType);
+	std::string getCreateMode() const;
+	void setCreateMode(const std::string &createMode);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	int getInternetMaxBandWidthIn() const;
+	void setInternetMaxBandWidthIn(int internetMaxBandWidthIn);
 	std::string getImageId() const;
 	void setImageId(const std::string &imageId);
 	std::string getSystemDiskLevel() const;
@@ -52,62 +94,43 @@ public:
 	void setJobQueue(const std::string &jobQueue);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
-	std::string getImageOwnerAlias() const;
-	void setImageOwnerAlias(const std::string &imageOwnerAlias);
 	std::string getSystemDiskType() const;
 	void setSystemDiskType(const std::string &systemDiskType);
-	std::vector<DataDisks> getDataDisks() const;
-	void setDataDisks(const std::vector<DataDisks> &dataDisks);
 	int getMinCount() const;
 	void setMinCount(int minCount);
-	int getSystemDiskSize() const;
-	void setSystemDiskSize(int systemDiskSize);
 	std::string getInstanceType() const;
 	void setInstanceType(const std::string &instanceType);
-	std::string getHostNamePrefix() const;
-	void setHostNamePrefix(const std::string &hostNamePrefix);
-	std::string getComputeSpotInterruptionBehavior() const;
-	void setComputeSpotInterruptionBehavior(const std::string &computeSpotInterruptionBehavior);
-	std::string getComputeSpotPriceLimit() const;
-	void setComputeSpotPriceLimit(const std::string &computeSpotPriceLimit);
-	int getAutoRenewPeriod() const;
-	void setAutoRenewPeriod(int autoRenewPeriod);
-	int getPeriod() const;
-	void setPeriod(int period);
-	int getCount() const;
-	void setCount(int count);
 	std::string getClusterId() const;
 	void setClusterId(const std::string &clusterId);
-	std::string getComputeSpotStrategy() const;
-	void setComputeSpotStrategy(const std::string &computeSpotStrategy);
-	std::string getHostNameSuffix() const;
-	void setHostNameSuffix(const std::string &hostNameSuffix);
-	bool getSync() const;
-	void setSync(bool sync);
 	std::string getNetworkInterfaceTrafficMode() const;
 	void setNetworkInterfaceTrafficMode(const std::string &networkInterfaceTrafficMode);
-	std::string getVSwitchId() const;
-	void setVSwitchId(const std::string &vSwitchId);
 	int getComputeSpotDuration() const;
 	void setComputeSpotDuration(int computeSpotDuration);
-	std::string getPeriodUnit() const;
-	void setPeriodUnit(const std::string &periodUnit);
-	bool getComputeEnableHt() const;
-	void setComputeEnableHt(bool computeEnableHt);
-	std::string getAutoRenew() const;
-	void setAutoRenew(const std::string &autoRenew);
 	std::string getEcsChargeType() const;
 	void setEcsChargeType(const std::string &ecsChargeType);
-	std::string getInternetChargeType() const;
-	void setInternetChargeType(const std::string &internetChargeType);
-	std::string getCreateMode() const;
-	void setCreateMode(const std::string &createMode);
-	std::string getZoneId() const;
-	void setZoneId(const std::string &zoneId);
-	int getInternetMaxBandWidthIn() const;
-	void setInternetMaxBandWidthIn(int internetMaxBandWidthIn);
 
 private:
+	std::string dnsConfig_;
+	std::string imageOwnerAlias_;
+	std::vector<DataDisks> dataDisks_;
+	int systemDiskSize_;
+	std::string hostNamePrefix_;
+	std::string computeSpotInterruptionBehavior_;
+	std::string computeSpotPriceLimit_;
+	int autoRenewPeriod_;
+	int period_;
+	int count_;
+	std::string computeSpotStrategy_;
+	std::string hostNameSuffix_;
+	bool sync_;
+	std::string vSwitchId_;
+	std::string periodUnit_;
+	bool computeEnableHt_;
+	std::string autoRenew_;
+	std::string internetChargeType_;
+	std::string createMode_;
+	std::string zoneId_;
+	int internetMaxBandWidthIn_;
 	std::string imageId_;
 	std::string systemDiskLevel_;
 	std::string clientToken_;
@@ -115,33 +138,13 @@ private:
 	int internetMaxBandWidthOut_;
 	std::string jobQueue_;
 	std::string accessKeyId_;
-	std::string imageOwnerAlias_;
 	std::string systemDiskType_;
-	std::vector<DataDisks> dataDisks_;
 	int minCount_;
-	int systemDiskSize_;
 	std::string instanceType_;
-	std::string hostNamePrefix_;
-	std::string computeSpotInterruptionBehavior_;
-	std::string computeSpotPriceLimit_;
-	int autoRenewPeriod_;
-	int period_;
-	int count_;
 	std::string clusterId_;
-	std::string computeSpotStrategy_;
-	std::string hostNameSuffix_;
-	bool sync_;
 	std::string networkInterfaceTrafficMode_;
-	std::string vSwitchId_;
 	int computeSpotDuration_;
-	std::string periodUnit_;
-	bool computeEnableHt_;
-	std::string autoRenew_;
 	std::string ecsChargeType_;
-	std::string internetChargeType_;
-	std::string createMode_;
-	std::string zoneId_;
-	int internetMaxBandWidthIn_;
 };
 } // namespace Model
 } // namespace EHPC

ehpc/include/alibabacloud/ehpc/model/AddQueueRequest.h

@@ -30,16 +30,22 @@ class ALIBABACLOUD_EHPC_EXPORT AddQueueRequest : public RpcServiceRequest {
 public:
 	AddQueueRequest();
 	~AddQueueRequest();
+	std::string getDeploymentSetId() const;
+	void setDeploymentSetId(const std::string &deploymentSetId);
 	std::string getQueueName() const;
 	void setQueueName(const std::string &queueName);
 	std::string getClusterId() const;
 	void setClusterId(const std::string &clusterId);
+	std::string getNetworkInterfaceTrafficMode() const;
+	void setNetworkInterfaceTrafficMode(const std::string &networkInterfaceTrafficMode);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
 
 private:
+	std::string deploymentSetId_;
 	std::string queueName_;
 	std::string clusterId_;
+	std::string networkInterfaceTrafficMode_;
 	std::string accessKeyId_;
 };
 } // namespace Model

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

@@ -43,6 +43,15 @@ public:
 		std::string location;
 		std::string jobQueue;
 	};
+	struct AddOns {
+		std::string deployMode;
+		float port;
+		std::string configFile;
+		bool defaultStart;
+		std::string name;
+		std::string dBType;
+		std::string version;
+	};
 	struct Tag {
 		std::string value;
 		std::string key;
@@ -58,12 +67,16 @@ public:
 	~CreateClusterRequest();
 	std::vector<AdditionalVolumes> getAdditionalVolumes() const;
 	void setAdditionalVolumes(const std::vector<AdditionalVolumes> &additionalVolumes);
+	std::vector<AddOns> getAddOns() const;
+	void setAddOns(const std::vector<AddOns> &addOns);
 	std::string getEcsOrderManagerInstanceType() const;
 	void setEcsOrderManagerInstanceType(const std::string &ecsOrderManagerInstanceType);
 	std::string getKeyPairName() const;
 	void setKeyPairName(const std::string &keyPairName);
 	std::string getSecurityGroupName() const;
 	void setSecurityGroupName(const std::string &securityGroupName);
+	bool getWithoutNas() const;
+	void setWithoutNas(bool withoutNas);
 	std::string getImageOwnerAlias() const;
 	void setImageOwnerAlias(const std::string &imageOwnerAlias);
 	std::string getDeployMode() const;
@@ -144,6 +157,8 @@ public:
 	void setVolumeType(const std::string &volumeType);
 	std::string getSystemDiskType() const;
 	void setSystemDiskType(const std::string &systemDiskType);
+	std::string getDeploymentSetId() const;
+	void setDeploymentSetId(const std::string &deploymentSetId);
 	std::string getVolumeProtocol() const;
 	void setVolumeProtocol(const std::string &volumeProtocol);
 	std::string getClientVersion() const;
@@ -181,9 +196,11 @@ public:
 
 private:
 	std::vector<AdditionalVolumes> additionalVolumes_;
+	std::vector<AddOns> addOns_;
 	std::string ecsOrderManagerInstanceType_;
 	std::string keyPairName_;
 	std::string securityGroupName_;
+	bool withoutNas_;
 	std::string imageOwnerAlias_;
 	std::string deployMode_;
 	int ecsOrderManagerCount_;
@@ -224,6 +241,7 @@ private:
 	std::string accessKeyId_;
 	std::string volumeType_;
 	std::string systemDiskType_;
+	std::string deploymentSetId_;
 	std::string volumeProtocol_;
 	std::string clientVersion_;
 	std::string osTag_;

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

@@ -39,6 +39,7 @@ public:
 		std::string url;
 	};
 	struct OpenldapPar {
+		std::string fallbackHomeDir;
 		std::string baseDn;
 		std::string ldapServerIp;
 	};
@@ -71,6 +72,8 @@ public:
 	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getPassword() const;
 	void setPassword(const std::string &password);
+	std::string getHybridClusterOpMode() const;
+	void setHybridClusterOpMode(const std::string &hybridClusterOpMode);
 	WinAdPar getWinAdPar() const;
 	void setWinAdPar(const WinAdPar &winAdPar);
 	float getComputeSpotPriceLimit() const;
@@ -147,6 +150,7 @@ private:
 	std::string imageOwnerAlias_;
 	std::string resourceGroupId_;
 	std::string password_;
+	std::string hybridClusterOpMode_;
 	WinAdPar winAdPar_;
 	float computeSpotPriceLimit_;
 	std::string onPremiseVolumeLocalPath_;

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

@@ -61,6 +61,12 @@ namespace AlibabaCloud
 						ProxyMgr proxyMgr;
 						Manager manager;
 					};
+					struct InitialImage
+					{
+						std::string imageOwnerAlias;
+						std::string osTag;
+						std::string imageId;
+					};
 					struct ApplicationInfo
 					{
 						std::string version;
@@ -78,40 +84,75 @@ namespace AlibabaCloud
 						std::string iP;
 						std::string hostName;
 					};
+					struct AddOnsInfoItem
+					{
+						std::string status;
+						std::string softwareId;
+						std::string deployMode;
+						int port;
+						std::string uRL;
+					};
+					struct NodesInfo
+					{
+						std::string role;
+						std::string ipAddress;
+						std::string schedulerType;
+						std::string dir;
+						std::string accountType;
+						std::string hostName;
+					};
 					std::string volumeProtocol;
+					std::string resourceGroupId;
+					std::vector<AddOnsInfoItem> addOnsInfo;
+					std::string name;
+					std::string volumeId;
+					std::string ramRoleName;
+					std::string deployMode;
+					std::string openldapPar;
+					std::string imageId;
+					std::string status;
+					std::vector<PostInstallScriptInfo> postInstallScripts;
+					std::string vSwitchId;
+					std::string period;
+					std::string computeSpotStrategy;
+					std::string volumeMountpoint;
+					std::string vpcId;
+					EcsInfo ecsInfo;
+					std::string id;
+					std::string domain;
+					InitialImage initialImage;
+					std::string periodUnit;
 					std::string imageOwnerAlias;
 					std::string description;
+					std::string autoRenew;
+					std::string computeSpotPriceLimit;
 					std::string ramNodeTypes;
 					std::string clientVersion;
 					std::vector<OnPremiseInfoItem> onPremiseInfo;
-					std::string name;
-					std::string volumeId;
+					std::string winAdPar;
 					std::string volumeType;
-					std::string ramRoleName;
-					std::string deployMode;
-					std::string imageId;
-					std::string status;
+					int schedulerPreInstall;
+					std::string autoRenewPeriod;
 					std::string keyPairName;
 					std::string remoteDirectory;
 					std::string sccClusterId;
 					std::vector<ApplicationInfo> applications;
-					std::vector<PostInstallScriptInfo> postInstallScripts;
+					std::string zoneId;
+					std::string clusterVersion;
 					std::string securityGroupId;
 					std::string createTime;
-					std::string vSwitchId;
 					std::string schedulerType;
 					std::string accountType;
+					std::vector<NodesInfo> nodes;
 					std::string baseOsTag;
-					std::string volumeMountpoint;
+					int withoutAgent;
 					std::string imageName;
-					std::string vpcId;
-					EcsInfo ecsInfo;
 					bool haEnable;
 					std::string osTag;
 					std::string ecsChargeType;
 					std::string regionId;
-					std::string id;
 					std::string location;
+					std::string plugin;
 				};
 
 

ehpc/include/alibabacloud/ehpc/model/DescribeServerlessJobsRequest.h

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

ehpc/include/alibabacloud/ehpc/model/DescribeServerlessJobsResult.h

@@ -0,0 +1,383 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_DESCRIBESERVERLESSJOBSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBESERVERLESSJOBSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT DescribeServerlessJobsResult : public ServiceResult
+			{
+			public:
+				struct JobInfo
+				{
+					struct ArrayProperties
+					{
+						long indexStart;
+						long indexEnd;
+						long indexStep;
+					};
+					struct ContainerGroup
+					{
+						struct DnsConfig
+						{
+							struct Option
+							{
+								std::string value;
+								std::string name;
+							};
+							std::vector<Option> options;
+							std::vector<std::string> searches;
+							std::vector<std::string> nameServers;
+						};
+						struct EciSecurityContext
+						{
+							struct Sysctl
+							{
+								std::string value;
+								std::string name;
+							};
+							std::vector<Sysctl> sysctls;
+						};
+						struct Container
+						{
+							struct CurrentState
+							{
+								long signal;
+								std::string finishTime;
+								std::string message;
+								std::string state;
+								long exitCode;
+								std::string startTime;
+								std::string detailStatus;
+								std::string reason;
+							};
+							struct LivenessProbe
+							{
+								struct HttpGet
+								{
+									std::string path;
+									std::string scheme;
+									long port;
+								};
+								struct TcpSocket
+								{
+									long port;
+									std::string host;
+								};
+								long initialDelaySeconds;
+								long timeoutSeconds;
+								std::vector<std::string> execs;
+								HttpGet httpGet;
+								long periodSeconds;
+								TcpSocket tcpSocket;
+								long failureThreshold;
+								long successThreshold;
+							};
+							struct PreviousState
+							{
+								long signal;
+								std::string finishTime;
+								std::string message;
+								std::string state;
+								long exitCode;
+								std::string startTime;
+								std::string detailStatus;
+								std::string reason;
+							};
+							struct ReadinessProbe
+							{
+								struct HttpGet2
+								{
+									std::string path;
+									std::string scheme;
+									long port;
+								};
+								struct TcpSocket3
+								{
+									long port;
+									std::string host;
+								};
+								long initialDelaySeconds;
+								long timeoutSeconds;
+								HttpGet2 httpGet2;
+								TcpSocket3 tcpSocket3;
+								std::vector<std::string> execs1;
+								long periodSeconds;
+								long failureThreshold;
+								long successThreshold;
+							};
+							struct SecurityContext
+							{
+								struct Capability
+								{
+									std::vector<std::string> adds;
+								};
+								long runAsUser;
+								Capability capability;
+								bool readOnlyRootFilesystem;
+							};
+							struct EnvironmentVar
+							{
+								struct ValueFrom
+								{
+									struct FieldRef
+									{
+										std::string fieldPath;
+									};
+									FieldRef fieldRef;
+								};
+								ValueFrom valueFrom;
+								std::string value;
+								std::string key;
+							};
+							struct Port
+							{
+								long port;
+								std::string protocol;
+							};
+							struct VolumeMount
+							{
+								std::string mountPath;
+								bool readOnly;
+								std::string subPath;
+								std::string mountPropagation;
+								std::string name;
+							};
+							ReadinessProbe readinessProbe;
+							std::vector<Container::EnvironmentVar> environmentVars;
+							std::vector<std::string> args;
+							LivenessProbe livenessProbe;
+							float memory;
+							std::vector<Container::Port> ports;
+							float cpu;
+							std::string image;
+							int gpu;
+							PreviousState previousState;
+							bool stdinOnce;
+							std::string name;
+							bool stdin;
+							int restartCount;
+							bool ready;
+							std::string workingDir;
+							std::vector<Container::VolumeMount> volumeMounts;
+							std::string imagePullPolicy;
+							CurrentState currentState;
+							SecurityContext securityContext;
+							bool tty;
+							std::vector<std::string> commands;
+						};
+						struct Event
+						{
+							std::string type;
+							std::string lastTimestamp;
+							std::string message;
+							int count;
+							std::string firstTimestamp;
+							std::string reason;
+							std::string name;
+						};
+						struct HostAlias
+						{
+							std::string ip;
+							std::vector<std::string> hostnames;
+						};
+						struct InitContainer
+						{
+							struct CurrentState5
+							{
+								long signal;
+								std::string finishTime;
+								std::string message;
+								std::string state;
+								long exitCode;
+								std::string startTime;
+								std::string detailStatus;
+								std::string reason;
+							};
+							struct PreviousState6
+							{
+								long signal;
+								std::string finishTime;
+								std::string message;
+								std::string state;
+								long exitCode;
+								std::string startTime;
+								std::string detailStatus;
+								std::string reason;
+							};
+							struct SecurityContext7
+							{
+								struct Capability16
+								{
+									std::vector<std::string> adds17;
+								};
+								long runAsUser;
+								bool readOnlyRootFilesystem;
+								Capability16 capability16;
+							};
+							struct EnvironmentVar11
+							{
+								struct ValueFrom12
+								{
+									struct FieldRef13
+									{
+										std::string fieldPath;
+									};
+									FieldRef13 fieldRef13;
+								};
+								std::string value;
+								std::string key;
+								ValueFrom12 valueFrom12;
+							};
+							struct Port14
+							{
+								long port;
+								std::string protocol;
+							};
+							struct VolumeMount15
+							{
+								std::string mountPath;
+								bool readOnly;
+								std::string mountPropagation;
+								std::string name;
+							};
+							PreviousState6 previousState6;
+							long memory;
+							long cpu;
+							std::string image;
+							long gpu;
+							std::string name;
+							CurrentState5 currentState5;
+							long restartCount;
+							std::vector<InitContainer::EnvironmentVar11> environmentVars8;
+							bool ready;
+							std::string workingDir;
+							std::vector<InitContainer::Port14> ports9;
+							std::vector<InitContainer::VolumeMount15> volumeMounts10;
+							std::string imagePullPolicy;
+							std::vector<std::string> command;
+							SecurityContext7 securityContext7;
+							std::vector<std::string> args4;
+						};
+						struct Tag
+						{
+							std::string value;
+							std::string key;
+						};
+						struct Volume
+						{
+							struct ConfigFileVolumeConfigFileToPath
+							{
+								std::string path;
+								std::string content;
+							};
+							std::string emptyDirVolumeSizeLimit;
+							std::string flexVolumeFsType;
+							std::string nFSVolumeServer;
+							std::vector<Volume::ConfigFileVolumeConfigFileToPath> configFileVolumeConfigFileToPaths;
+							bool nFSVolumeReadOnly;
+							std::string name;
+							std::string nFSVolumePath;
+							std::string type;
+							std::string flexVolumeDriver;
+							std::string diskVolumeDiskId;
+							std::string flexVolumeOptions;
+							std::string emptyDirVolumeMedium;
+							std::string diskVolumeFsType;
+						};
+						long discount;
+						std::string resourceGroupId;
+						float memory;
+						std::vector<ContainerGroup::Container> containers;
+						float cpu;
+						EciSecurityContext eciSecurityContext;
+						std::string tenantSecurityGroupId;
+						std::string failedTime;
+						std::string containerGroupName;
+						std::string intranetIp;
+						std::vector<ContainerGroup::Volume> volumes;
+						std::string ramRoleName;
+						DnsConfig dnsConfig;
+						std::string internetIp;
+						std::vector<ContainerGroup::Event> events;
+						std::string expiredTime;
+						float spotPriceLimit;
+						std::string instanceType;
+						std::vector<ContainerGroup::Tag> tags;
+						std::string ipv6Address;
+						std::string spotStrategy;
+						std::string status;
+						std::string tenantEniIp;
+						std::vector<ContainerGroup::InitContainer> initContainers;
+						std::string zoneId;
+						std::string succeededTime;
+						std::string securityGroupId;
+						std::string vSwitchId;
+						std::string restartPolicy;
+						std::string tenantEniInstanceId;
+						std::vector<ContainerGroup::HostAlias> hostAliases;
+						std::string tenantVSwitchId;
+						std::string vpcId;
+						std::string creationTime;
+						std::string eniInstanceId;
+						std::string containerGroupId;
+						std::string regionId;
+						long ephemeralStorage;
+					};
+					std::string owner;
+					std::vector<JobInfo::ContainerGroup> containerGroups;
+					long endTime;
+					long priority;
+					long startTime;
+					long lastModifyTime;
+					long submitTime;
+					std::string name;
+					ArrayProperties arrayProperties;
+					std::string state;
+					bool isArrayJob;
+					std::string id;
+					std::string queue;
+				};
+
+
+				DescribeServerlessJobsResult();
+				explicit DescribeServerlessJobsResult(const std::string &payload);
+				~DescribeServerlessJobsResult();
+				int getTotalCount()const;
+				std::vector<JobInfo> getJobInfos()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::vector<JobInfo> jobInfos_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBESERVERLESSJOBSRESULT_H_

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

@@ -57,6 +57,7 @@ namespace AlibabaCloud
 					std::string hostNameSuffix;
 					int minNodesInQueue;
 					int maxNodesInQueue;
+					bool sortedByInventory;
 					std::vector<QueueInfo::DataDisksInfo> dataDisks;
 					bool enableAutoGrow;
 					std::string resourceGroupId;
@@ -81,6 +82,7 @@ namespace AlibabaCloud
 				~GetAutoScaleConfigResult();
 				int getExtraNodesGrowRatio()const;
 				bool getEnableAutoGrow()const;
+				bool getComputeEnableHt()const;
 				std::string getClusterId()const;
 				int getMaxNodesInCluster()const;
 				int getShrinkIdleTimes()const;
@@ -90,6 +92,7 @@ namespace AlibabaCloud
 				int getGrowIntervalInMinutes()const;
 				std::string getUid()const;
 				int getGrowTimeoutInMinutes()const;
+				std::string getDnsConfig()const;
 				std::string getImageId()const;
 				int getShrinkIntervalInMinutes()const;
 				float getSpotPriceLimit()const;
@@ -102,6 +105,7 @@ namespace AlibabaCloud
 			private:
 				int extraNodesGrowRatio_;
 				bool enableAutoGrow_;
+				bool computeEnableHt_;
 				std::string clusterId_;
 				int maxNodesInCluster_;
 				int shrinkIdleTimes_;
@@ -111,6 +115,7 @@ namespace AlibabaCloud
 				int growIntervalInMinutes_;
 				std::string uid_;
 				int growTimeoutInMinutes_;
+				std::string dnsConfig_;
 				std::string imageId_;
 				int shrinkIntervalInMinutes_;
 				float spotPriceLimit_;

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

@@ -64,6 +64,7 @@ namespace AlibabaCloud
 					};
 					std::string imageOwnerAlias;
 					std::string description;
+					std::string resourceGroupId;
 					std::string nodePrefix;
 					std::string instanceChargeType;
 					float computeSpotPriceLimit;

ehpc/include/alibabacloud/ehpc/model/ListQueuesResult.h

@@ -39,6 +39,7 @@ namespace AlibabaCloud
 						float spotPriceLimit;
 						std::string instanceType;
 					};
+					std::string deploymentSetId;
 					std::string hostNameSuffix;
 					std::string type;
 					std::vector<QueueInfo::Instance> spotInstanceTypes;

ehpc/include/alibabacloud/ehpc/model/ListServerlessJobsRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_LISTSERVERLESSJOBSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTSERVERLESSJOBSREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT ListServerlessJobsRequest : public RpcServiceRequest {
+public:
+	ListServerlessJobsRequest();
+	~ListServerlessJobsRequest();
+	std::string getSubmitTimeStart() const;
+	void setSubmitTimeStart(const std::string &submitTimeStart);
+	long getPageNumber() const;
+	void setPageNumber(long pageNumber);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	long getPageSize() const;
+	void setPageSize(long pageSize);
+	std::string getState() const;
+	void setState(const std::string &state);
+	std::string getSubmitOrder() const;
+	void setSubmitOrder(const std::string &submitOrder);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::vector<std::string> getJobNames() const;
+	void setJobNames(const std::vector<std::string> &jobNames);
+	std::vector<std::string> getUsers() const;
+	void setUsers(const std::vector<std::string> &users);
+	std::string getStartOrder() const;
+	void setStartOrder(const std::string &startOrder);
+	std::string getSubmitTimeEnd() const;
+	void setSubmitTimeEnd(const std::string &submitTimeEnd);
+	std::vector<std::string> getQueues() const;
+	void setQueues(const std::vector<std::string> &queues);
+	std::vector<std::string> getJobIds() const;
+	void setJobIds(const std::vector<std::string> &jobIds);
+
+private:
+	std::string submitTimeStart_;
+	long pageNumber_;
+	std::string regionId_;
+	long pageSize_;
+	std::string state_;
+	std::string submitOrder_;
+	std::string clusterId_;
+	std::vector<std::string> jobNames_;
+	std::vector<std::string> users_;
+	std::string startOrder_;
+	std::string submitTimeEnd_;
+	std::vector<std::string> queues_;
+	std::vector<std::string> jobIds_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTSERVERLESSJOBSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListServerlessJobsResult.h

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

ehpc/include/alibabacloud/ehpc/model/ModifyClusterAttributesRequest.h

@@ -28,6 +28,13 @@ namespace EHPC {
 namespace Model {
 class ALIBABACLOUD_EHPC_EXPORT ModifyClusterAttributesRequest : public RpcServiceRequest {
 public:
+	struct WinAdPar {
+		std::string adUser;
+		std::string adUserPasswd;
+		std::string adIp;
+		std::string fallbackHomeDir;
+		std::string adDc;
+	};
 	ModifyClusterAttributesRequest();
 	~ModifyClusterAttributesRequest();
 	std::string getImageId() const;
@@ -46,6 +53,8 @@ public:
 	void setRamNodeTypes(const std::vector<std::string> &ramNodeTypes);
 	std::string getPassword() const;
 	void setPassword(const std::string &password);
+	WinAdPar getWinAdPar() const;
+	void setWinAdPar(const WinAdPar &winAdPar);
 	std::string getName() const;
 	void setName(const std::string &name);
 
@@ -58,6 +67,7 @@ private:
 	std::string imageOwnerAlias_;
 	std::vector<std::string> ramNodeTypes_;
 	std::string password_;
+	WinAdPar winAdPar_;
 	std::string name_;
 };
 } // namespace Model

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

@@ -31,6 +31,7 @@ public:
 	struct Queues {
 		std::string queueName;
 		std::string systemDiskLevel;
+		bool sortedByInventory;
 		struct InstanceTypes {
 			std::string vSwitchId;
 			std::string spotStrategy;
@@ -69,6 +70,8 @@ public:
 	~SetAutoScaleConfigRequest();
 	std::string getImageId() const;
 	void setImageId(const std::string &imageId);
+	std::string getDnsConfig() const;
+	void setDnsConfig(const std::string &dnsConfig);
 	float getSpotPriceLimit() const;
 	void setSpotPriceLimit(float spotPriceLimit);
 	std::string getAccessKeyId() const;
@@ -91,6 +94,8 @@ public:
 	void setSpotStrategy(const std::string &spotStrategy);
 	int getMaxNodesInCluster() const;
 	void setMaxNodesInCluster(int maxNodesInCluster);
+	bool getComputeEnableHt() const;
+	void setComputeEnableHt(bool computeEnableHt);
 	int getShrinkIntervalInMinutes() const;
 	void setShrinkIntervalInMinutes(int shrinkIntervalInMinutes);
 	std::vector<Queues> getQueues() const;
@@ -102,6 +107,7 @@ public:
 
 private:
 	std::string imageId_;
+	std::string dnsConfig_;
 	float spotPriceLimit_;
 	std::string accessKeyId_;
 	std::string excludeNodes_;
@@ -113,6 +119,7 @@ private:
 	bool enableAutoShrink_;
 	std::string spotStrategy_;
 	int maxNodesInCluster_;
+	bool computeEnableHt_;
 	int shrinkIntervalInMinutes_;
 	std::vector<Queues> queues_;
 	int growIntervalInMinutes_;

ehpc/include/alibabacloud/ehpc/model/StopServerlessJobsRequest.h

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

ehpc/include/alibabacloud/ehpc/model/StopServerlessJobsResult.h

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

ehpc/include/alibabacloud/ehpc/model/SubmitServerlessJobRequest.h

@@ -0,0 +1,170 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_SUBMITSERVERLESSJOBREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_SUBMITSERVERLESSJOBREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT SubmitServerlessJobRequest : public RpcServiceRequest {
+public:
+	struct Container {
+		struct VolumeMountItem {
+			std::string flexVolumeOptions;
+			std::string nFSVolumeServer;
+			std::string mountPath;
+			bool readOnly;
+			std::string mountPropagation;
+			std::string subPath;
+			std::string nFSVolumePath;
+			std::string type;
+			bool nFSVolumeReadOnly;
+			std::string flexVolumeDriver;
+		};
+		VolumeMountItem volumeMountItem;
+		std::vector<VolumeMountItem> volumeMount;
+		std::string image;
+		struct PortItem {
+			std::string protocol;
+			int port;
+		};
+		PortItem portItem;
+		std::vector<PortItem> port;
+		struct EnvironmentVarItem {
+			std::string name;
+			std::string value;
+		};
+		EnvironmentVarItem environmentVarItem;
+		std::vector<EnvironmentVarItem> environmentVar;
+		std::string workingDir;
+		std::string string;
+		std::vector<std::string> arg;
+		std::string name;
+		int gpu;
+		std::string string;
+		std::vector<std::string> command;
+	};
+	struct DependsOn {
+		std::string jobId;
+		std::string type;
+	};
+	struct AcrRegistryInfo {
+		std::string instanceName;
+		std::string instanceId;
+		std::string regionId;
+		std::string string;
+		std::vector<std::string> domain;
+	};
+	struct Volume {
+		std::string flexVolumeOptions;
+		std::string nFSVolumeServer;
+		std::string nFSVolumePath;
+		bool nFSVolumeReadOnly;
+		std::string flexVolumeDriver;
+	};
+	struct RetryStrategy {
+		struct EvaluateOnExitItem {
+			std::string action;
+			std::string onExitCode;
+		};
+		EvaluateOnExitItem evaluateOnExitItem;
+		std::vector<EvaluateOnExitItem> evaluateOnExit;
+		int attempts;
+	};
+	struct ArrayProperties {
+		long indexStart;
+		long indexStep;
+		long indexEnd;
+	};
+	SubmitServerlessJobRequest();
+	~SubmitServerlessJobRequest();
+	Container getContainer() const;
+	void setContainer(const Container &container);
+	float getMemory() const;
+	void setMemory(float memory);
+	std::vector<DependsOn> getDependsOn() const;
+	void setDependsOn(const std::vector<DependsOn> &dependsOn);
+	float getSpotPriceLimit() const;
+	void setSpotPriceLimit(float spotPriceLimit);
+	std::string getJobQueue() const;
+	void setJobQueue(const std::string &jobQueue);
+	long getTimeout() const;
+	void setTimeout(long timeout);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getJobUser() const;
+	void setJobUser(const std::string &jobUser);
+	std::vector<std::string> getInstanceType() const;
+	void setInstanceType(const std::vector<std::string> &instanceType);
+	std::string getJobName() const;
+	void setJobName(const std::string &jobName);
+	long getJobPriority() const;
+	void setJobPriority(long jobPriority);
+	float getCpu() const;
+	void setCpu(float cpu);
+	std::string getRamRoleName() const;
+	void setRamRoleName(const std::string &ramRoleName);
+	std::vector<AcrRegistryInfo> getAcrRegistryInfo() const;
+	void setAcrRegistryInfo(const std::vector<AcrRegistryInfo> &acrRegistryInfo);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getSpotStrategy() const;
+	void setSpotStrategy(const std::string &spotStrategy);
+	std::vector<std::string> getVSwitchId() const;
+	void setVSwitchId(const std::vector<std::string> &vSwitchId);
+	std::vector<Volume> getVolume() const;
+	void setVolume(const std::vector<Volume> &volume);
+	RetryStrategy getRetryStrategy() const;
+	void setRetryStrategy(const RetryStrategy &retryStrategy);
+	int getEphemeralStorage() const;
+	void setEphemeralStorage(int ephemeralStorage);
+	ArrayProperties getArrayProperties() const;
+	void setArrayProperties(const ArrayProperties &arrayProperties);
+
+private:
+	Container container_;
+	float memory_;
+	std::vector<DependsOn> dependsOn_;
+	float spotPriceLimit_;
+	std::string jobQueue_;
+	long timeout_;
+	std::string accessKeyId_;
+	std::string jobUser_;
+	std::vector<std::string> instanceType_;
+	std::string jobName_;
+	long jobPriority_;
+	float cpu_;
+	std::string ramRoleName_;
+	std::vector<AcrRegistryInfo> acrRegistryInfo_;
+	std::string clusterId_;
+	std::string spotStrategy_;
+	std::vector<std::string> vSwitchId_;
+	std::vector<Volume> volume_;
+	RetryStrategy retryStrategy_;
+	int ephemeralStorage_;
+	ArrayProperties arrayProperties_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_SUBMITSERVERLESSJOBREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/SubmitServerlessJobResult.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_EHPC_MODEL_SUBMITSERVERLESSJOBRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_SUBMITSERVERLESSJOBRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT SubmitServerlessJobResult : public ServiceResult
+			{
+			public:
+
+
+				SubmitServerlessJobResult();
+				explicit SubmitServerlessJobResult(const std::string &payload);
+				~SubmitServerlessJobResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_SUBMITSERVERLESSJOBRESULT_H_

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

@@ -31,6 +31,7 @@ public:
 	struct AdditionalVolumes {
 		std::string volumeType;
 		std::string volumeProtocol;
+		std::string volumeMountOption;
 		std::string localDirectory;
 		std::string remoteDirectory;
 		struct Roles {

ehpc/include/alibabacloud/ehpc/model/UpdateQueueConfigRequest.h

@@ -30,6 +30,8 @@ class ALIBABACLOUD_EHPC_EXPORT UpdateQueueConfigRequest : public RpcServiceReque
 public:
 	UpdateQueueConfigRequest();
 	~UpdateQueueConfigRequest();
+	std::string getDeploymentSetId() const;
+	void setDeploymentSetId(const std::string &deploymentSetId);
 	std::string getQueueName() const;
 	void setQueueName(const std::string &queueName);
 	std::string getClusterId() const;
@@ -42,6 +44,7 @@ public:
 	void setComputeInstanceType(const std::string &computeInstanceType);
 
 private:
+	std::string deploymentSetId_;
 	std::string queueName_;
 	std::string clusterId_;
 	std::string accessKeyId_;

ehpc/src/EHPCClient.cc

@@ -1527,6 +1527,42 @@ EHPCClient::DescribePriceOutcomeCallable EHPCClient::describePriceCallable(const
 	return task->get_future();
 }
 
+EHPCClient::DescribeServerlessJobsOutcome EHPCClient::describeServerlessJobs(const DescribeServerlessJobsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeServerlessJobsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeServerlessJobsOutcome(DescribeServerlessJobsResult(outcome.result()));
+	else
+		return DescribeServerlessJobsOutcome(outcome.error());
+}
+
+void EHPCClient::describeServerlessJobsAsync(const DescribeServerlessJobsRequest& request, const DescribeServerlessJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeServerlessJobs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::DescribeServerlessJobsOutcomeCallable EHPCClient::describeServerlessJobsCallable(const DescribeServerlessJobsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeServerlessJobsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeServerlessJobs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::EditJobTemplateOutcome EHPCClient::editJobTemplate(const EditJobTemplateRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3183,6 +3219,42 @@ EHPCClient::ListSecurityGroupsOutcomeCallable EHPCClient::listSecurityGroupsCall
 	return task->get_future();
 }
 
+EHPCClient::ListServerlessJobsOutcome EHPCClient::listServerlessJobs(const ListServerlessJobsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListServerlessJobsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListServerlessJobsOutcome(ListServerlessJobsResult(outcome.result()));
+	else
+		return ListServerlessJobsOutcome(outcome.error());
+}
+
+void EHPCClient::listServerlessJobsAsync(const ListServerlessJobsRequest& request, const ListServerlessJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listServerlessJobs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ListServerlessJobsOutcomeCallable EHPCClient::listServerlessJobsCallable(const ListServerlessJobsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListServerlessJobsOutcome()>>(
+			[this, request]()
+			{
+			return this->listServerlessJobs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::ListSoftwaresOutcome EHPCClient::listSoftwares(const ListSoftwaresRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4443,6 +4515,42 @@ EHPCClient::StopNodesOutcomeCallable EHPCClient::stopNodesCallable(const StopNod
 	return task->get_future();
 }
 
+EHPCClient::StopServerlessJobsOutcome EHPCClient::stopServerlessJobs(const StopServerlessJobsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopServerlessJobsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopServerlessJobsOutcome(StopServerlessJobsResult(outcome.result()));
+	else
+		return StopServerlessJobsOutcome(outcome.error());
+}
+
+void EHPCClient::stopServerlessJobsAsync(const StopServerlessJobsRequest& request, const StopServerlessJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopServerlessJobs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::StopServerlessJobsOutcomeCallable EHPCClient::stopServerlessJobsCallable(const StopServerlessJobsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopServerlessJobsOutcome()>>(
+			[this, request]()
+			{
+			return this->stopServerlessJobs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::StopVisualServiceOutcome EHPCClient::stopVisualService(const StopVisualServiceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4515,6 +4623,42 @@ EHPCClient::SubmitJobOutcomeCallable EHPCClient::submitJobCallable(const SubmitJ
 	return task->get_future();
 }
 
+EHPCClient::SubmitServerlessJobOutcome EHPCClient::submitServerlessJob(const SubmitServerlessJobRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SubmitServerlessJobOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SubmitServerlessJobOutcome(SubmitServerlessJobResult(outcome.result()));
+	else
+		return SubmitServerlessJobOutcome(outcome.error());
+}
+
+void EHPCClient::submitServerlessJobAsync(const SubmitServerlessJobRequest& request, const SubmitServerlessJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, submitServerlessJob(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::SubmitServerlessJobOutcomeCallable EHPCClient::submitServerlessJobCallable(const SubmitServerlessJobRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SubmitServerlessJobOutcome()>>(
+			[this, request]()
+			{
+			return this->submitServerlessJob(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::SummaryImagesOutcome EHPCClient::summaryImages(const SummaryImagesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ehpc/src/model/AddNodesRequest.cc

@@ -25,6 +25,204 @@ AddNodesRequest::AddNodesRequest()
 
 AddNodesRequest::~AddNodesRequest() {}
 
+std::string AddNodesRequest::getDnsConfig() const {
+  return dnsConfig_;
+}
+
+void AddNodesRequest::setDnsConfig(const std::string &dnsConfig) {
+  dnsConfig_ = dnsConfig;
+  setParameter(std::string("DnsConfig"), dnsConfig);
+}
+
+std::string AddNodesRequest::getImageOwnerAlias() const {
+  return imageOwnerAlias_;
+}
+
+void AddNodesRequest::setImageOwnerAlias(const std::string &imageOwnerAlias) {
+  imageOwnerAlias_ = imageOwnerAlias;
+  setParameter(std::string("ImageOwnerAlias"), imageOwnerAlias);
+}
+
+std::vector<AddNodesRequest::DataDisks> AddNodesRequest::getDataDisks() const {
+  return dataDisks_;
+}
+
+void AddNodesRequest::setDataDisks(const std::vector<AddNodesRequest::DataDisks> &dataDisks) {
+  dataDisks_ = dataDisks;
+  for(int dep1 = 0; dep1 != dataDisks.size(); dep1++) {
+  auto dataDisksObj = dataDisks.at(dep1);
+  std::string dataDisksObjStr = std::string("DataDisks") + "." + std::to_string(dep1 + 1);
+    setParameter(dataDisksObjStr + ".DataDiskDeleteWithInstance", dataDisksObj.dataDiskDeleteWithInstance ? "true" : "false");
+    setParameter(dataDisksObjStr + ".DataDiskEncrypted", dataDisksObj.dataDiskEncrypted ? "true" : "false");
+    setParameter(dataDisksObjStr + ".DataDiskKMSKeyId", dataDisksObj.dataDiskKMSKeyId);
+    setParameter(dataDisksObjStr + ".DataDiskSize", std::to_string(dataDisksObj.dataDiskSize));
+    setParameter(dataDisksObjStr + ".DataDiskCategory", dataDisksObj.dataDiskCategory);
+    setParameter(dataDisksObjStr + ".DataDiskPerformanceLevel", dataDisksObj.dataDiskPerformanceLevel);
+  }
+}
+
+int AddNodesRequest::getSystemDiskSize() const {
+  return systemDiskSize_;
+}
+
+void AddNodesRequest::setSystemDiskSize(int systemDiskSize) {
+  systemDiskSize_ = systemDiskSize;
+  setParameter(std::string("SystemDiskSize"), std::to_string(systemDiskSize));
+}
+
+std::string AddNodesRequest::getHostNamePrefix() const {
+  return hostNamePrefix_;
+}
+
+void AddNodesRequest::setHostNamePrefix(const std::string &hostNamePrefix) {
+  hostNamePrefix_ = hostNamePrefix;
+  setParameter(std::string("HostNamePrefix"), hostNamePrefix);
+}
+
+std::string AddNodesRequest::getComputeSpotInterruptionBehavior() const {
+  return computeSpotInterruptionBehavior_;
+}
+
+void AddNodesRequest::setComputeSpotInterruptionBehavior(const std::string &computeSpotInterruptionBehavior) {
+  computeSpotInterruptionBehavior_ = computeSpotInterruptionBehavior;
+  setParameter(std::string("ComputeSpotInterruptionBehavior"), computeSpotInterruptionBehavior);
+}
+
+std::string AddNodesRequest::getComputeSpotPriceLimit() const {
+  return computeSpotPriceLimit_;
+}
+
+void AddNodesRequest::setComputeSpotPriceLimit(const std::string &computeSpotPriceLimit) {
+  computeSpotPriceLimit_ = computeSpotPriceLimit;
+  setParameter(std::string("ComputeSpotPriceLimit"), computeSpotPriceLimit);
+}
+
+int AddNodesRequest::getAutoRenewPeriod() const {
+  return autoRenewPeriod_;
+}
+
+void AddNodesRequest::setAutoRenewPeriod(int autoRenewPeriod) {
+  autoRenewPeriod_ = autoRenewPeriod;
+  setParameter(std::string("AutoRenewPeriod"), std::to_string(autoRenewPeriod));
+}
+
+int AddNodesRequest::getPeriod() const {
+  return period_;
+}
+
+void AddNodesRequest::setPeriod(int period) {
+  period_ = period;
+  setParameter(std::string("Period"), std::to_string(period));
+}
+
+int AddNodesRequest::getCount() const {
+  return count_;
+}
+
+void AddNodesRequest::setCount(int count) {
+  count_ = count;
+  setParameter(std::string("Count"), std::to_string(count));
+}
+
+std::string AddNodesRequest::getComputeSpotStrategy() const {
+  return computeSpotStrategy_;
+}
+
+void AddNodesRequest::setComputeSpotStrategy(const std::string &computeSpotStrategy) {
+  computeSpotStrategy_ = computeSpotStrategy;
+  setParameter(std::string("ComputeSpotStrategy"), computeSpotStrategy);
+}
+
+std::string AddNodesRequest::getHostNameSuffix() const {
+  return hostNameSuffix_;
+}
+
+void AddNodesRequest::setHostNameSuffix(const std::string &hostNameSuffix) {
+  hostNameSuffix_ = hostNameSuffix;
+  setParameter(std::string("HostNameSuffix"), hostNameSuffix);
+}
+
+bool AddNodesRequest::getSync() const {
+  return sync_;
+}
+
+void AddNodesRequest::setSync(bool sync) {
+  sync_ = sync;
+  setParameter(std::string("Sync"), sync ? "true" : "false");
+}
+
+std::string AddNodesRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void AddNodesRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
+std::string AddNodesRequest::getPeriodUnit() const {
+  return periodUnit_;
+}
+
+void AddNodesRequest::setPeriodUnit(const std::string &periodUnit) {
+  periodUnit_ = periodUnit;
+  setParameter(std::string("PeriodUnit"), periodUnit);
+}
+
+bool AddNodesRequest::getComputeEnableHt() const {
+  return computeEnableHt_;
+}
+
+void AddNodesRequest::setComputeEnableHt(bool computeEnableHt) {
+  computeEnableHt_ = computeEnableHt;
+  setParameter(std::string("ComputeEnableHt"), computeEnableHt ? "true" : "false");
+}
+
+std::string AddNodesRequest::getAutoRenew() const {
+  return autoRenew_;
+}
+
+void AddNodesRequest::setAutoRenew(const std::string &autoRenew) {
+  autoRenew_ = autoRenew;
+  setParameter(std::string("AutoRenew"), autoRenew);
+}
+
+std::string AddNodesRequest::getInternetChargeType() const {
+  return internetChargeType_;
+}
+
+void AddNodesRequest::setInternetChargeType(const std::string &internetChargeType) {
+  internetChargeType_ = internetChargeType;
+  setParameter(std::string("InternetChargeType"), internetChargeType);
+}
+
+std::string AddNodesRequest::getCreateMode() const {
+  return createMode_;
+}
+
+void AddNodesRequest::setCreateMode(const std::string &createMode) {
+  createMode_ = createMode;
+  setParameter(std::string("CreateMode"), createMode);
+}
+
+std::string AddNodesRequest::getZoneId() const {
+  return zoneId_;
+}
+
+void AddNodesRequest::setZoneId(const std::string &zoneId) {
+  zoneId_ = zoneId;
+  setParameter(std::string("ZoneId"), zoneId);
+}
+
+int AddNodesRequest::getInternetMaxBandWidthIn() const {
+  return internetMaxBandWidthIn_;
+}
+
+void AddNodesRequest::setInternetMaxBandWidthIn(int internetMaxBandWidthIn) {
+  internetMaxBandWidthIn_ = internetMaxBandWidthIn;
+  setParameter(std::string("InternetMaxBandWidthIn"), std::to_string(internetMaxBandWidthIn));
+}
+
 std::string AddNodesRequest::getImageId() const {
   return imageId_;
 }
@@ -88,15 +286,6 @@ void AddNodesRequest::setAccessKeyId(const std::string &accessKeyId) {
   setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-std::string AddNodesRequest::getImageOwnerAlias() const {
-  return imageOwnerAlias_;
-}
-
-void AddNodesRequest::setImageOwnerAlias(const std::string &imageOwnerAlias) {
-  imageOwnerAlias_ = imageOwnerAlias;
-  setParameter(std::string("ImageOwnerAlias"), imageOwnerAlias);
-}
-
 std::string AddNodesRequest::getSystemDiskType() const {
   return systemDiskType_;
 }
@@ -106,24 +295,6 @@ void AddNodesRequest::setSystemDiskType(const std::string &systemDiskType) {
   setParameter(std::string("SystemDiskType"), systemDiskType);
 }
 
-std::vector<AddNodesRequest::DataDisks> AddNodesRequest::getDataDisks() const {
-  return dataDisks_;
-}
-
-void AddNodesRequest::setDataDisks(const std::vector<AddNodesRequest::DataDisks> &dataDisks) {
-  dataDisks_ = dataDisks;
-  for(int dep1 = 0; dep1 != dataDisks.size(); dep1++) {
-  auto dataDisksObj = dataDisks.at(dep1);
-  std::string dataDisksObjStr = std::string("DataDisks") + "." + std::to_string(dep1 + 1);
-    setParameter(dataDisksObjStr + ".DataDiskDeleteWithInstance", dataDisksObj.dataDiskDeleteWithInstance ? "true" : "false");
-    setParameter(dataDisksObjStr + ".DataDiskEncrypted", dataDisksObj.dataDiskEncrypted ? "true" : "false");
-    setParameter(dataDisksObjStr + ".DataDiskKMSKeyId", dataDisksObj.dataDiskKMSKeyId);
-    setParameter(dataDisksObjStr + ".DataDiskSize", std::to_string(dataDisksObj.dataDiskSize));
-    setParameter(dataDisksObjStr + ".DataDiskCategory", dataDisksObj.dataDiskCategory);
-    setParameter(dataDisksObjStr + ".DataDiskPerformanceLevel", dataDisksObj.dataDiskPerformanceLevel);
-  }
-}
-
 int AddNodesRequest::getMinCount() const {
   return minCount_;
 }
@@ -133,15 +304,6 @@ void AddNodesRequest::setMinCount(int minCount) {
   setParameter(std::string("MinCount"), std::to_string(minCount));
 }
 
-int AddNodesRequest::getSystemDiskSize() const {
-  return systemDiskSize_;
-}
-
-void AddNodesRequest::setSystemDiskSize(int systemDiskSize) {
-  systemDiskSize_ = systemDiskSize;
-  setParameter(std::string("SystemDiskSize"), std::to_string(systemDiskSize));
-}
-
 std::string AddNodesRequest::getInstanceType() const {
   return instanceType_;
 }
@@ -151,60 +313,6 @@ void AddNodesRequest::setInstanceType(const std::string &instanceType) {
   setParameter(std::string("InstanceType"), instanceType);
 }
 
-std::string AddNodesRequest::getHostNamePrefix() const {
-  return hostNamePrefix_;
-}
-
-void AddNodesRequest::setHostNamePrefix(const std::string &hostNamePrefix) {
-  hostNamePrefix_ = hostNamePrefix;
-  setParameter(std::string("HostNamePrefix"), hostNamePrefix);
-}
-
-std::string AddNodesRequest::getComputeSpotInterruptionBehavior() const {
-  return computeSpotInterruptionBehavior_;
-}
-
-void AddNodesRequest::setComputeSpotInterruptionBehavior(const std::string &computeSpotInterruptionBehavior) {
-  computeSpotInterruptionBehavior_ = computeSpotInterruptionBehavior;
-  setParameter(std::string("ComputeSpotInterruptionBehavior"), computeSpotInterruptionBehavior);
-}
-
-std::string AddNodesRequest::getComputeSpotPriceLimit() const {
-  return computeSpotPriceLimit_;
-}
-
-void AddNodesRequest::setComputeSpotPriceLimit(const std::string &computeSpotPriceLimit) {
-  computeSpotPriceLimit_ = computeSpotPriceLimit;
-  setParameter(std::string("ComputeSpotPriceLimit"), computeSpotPriceLimit);
-}
-
-int AddNodesRequest::getAutoRenewPeriod() const {
-  return autoRenewPeriod_;
-}
-
-void AddNodesRequest::setAutoRenewPeriod(int autoRenewPeriod) {
-  autoRenewPeriod_ = autoRenewPeriod;
-  setParameter(std::string("AutoRenewPeriod"), std::to_string(autoRenewPeriod));
-}
-
-int AddNodesRequest::getPeriod() const {
-  return period_;
-}
-
-void AddNodesRequest::setPeriod(int period) {
-  period_ = period;
-  setParameter(std::string("Period"), std::to_string(period));
-}
-
-int AddNodesRequest::getCount() const {
-  return count_;
-}
-
-void AddNodesRequest::setCount(int count) {
-  count_ = count;
-  setParameter(std::string("Count"), std::to_string(count));
-}
-
 std::string AddNodesRequest::getClusterId() const {
   return clusterId_;
 }
@@ -214,33 +322,6 @@ void AddNodesRequest::setClusterId(const std::string &clusterId) {
   setParameter(std::string("ClusterId"), clusterId);
 }
 
-std::string AddNodesRequest::getComputeSpotStrategy() const {
-  return computeSpotStrategy_;
-}
-
-void AddNodesRequest::setComputeSpotStrategy(const std::string &computeSpotStrategy) {
-  computeSpotStrategy_ = computeSpotStrategy;
-  setParameter(std::string("ComputeSpotStrategy"), computeSpotStrategy);
-}
-
-std::string AddNodesRequest::getHostNameSuffix() const {
-  return hostNameSuffix_;
-}
-
-void AddNodesRequest::setHostNameSuffix(const std::string &hostNameSuffix) {
-  hostNameSuffix_ = hostNameSuffix;
-  setParameter(std::string("HostNameSuffix"), hostNameSuffix);
-}
-
-bool AddNodesRequest::getSync() const {
-  return sync_;
-}
-
-void AddNodesRequest::setSync(bool sync) {
-  sync_ = sync;
-  setParameter(std::string("Sync"), sync ? "true" : "false");
-}
-
 std::string AddNodesRequest::getNetworkInterfaceTrafficMode() const {
   return networkInterfaceTrafficMode_;
 }
@@ -250,15 +331,6 @@ void AddNodesRequest::setNetworkInterfaceTrafficMode(const std::string &networkI
   setParameter(std::string("NetworkInterfaceTrafficMode"), networkInterfaceTrafficMode);
 }
 
-std::string AddNodesRequest::getVSwitchId() const {
-  return vSwitchId_;
-}
-
-void AddNodesRequest::setVSwitchId(const std::string &vSwitchId) {
-  vSwitchId_ = vSwitchId;
-  setParameter(std::string("VSwitchId"), vSwitchId);
-}
-
 int AddNodesRequest::getComputeSpotDuration() const {
   return computeSpotDuration_;
 }
@@ -268,33 +340,6 @@ void AddNodesRequest::setComputeSpotDuration(int computeSpotDuration) {
   setParameter(std::string("ComputeSpotDuration"), std::to_string(computeSpotDuration));
 }
 
-std::string AddNodesRequest::getPeriodUnit() const {
-  return periodUnit_;
-}
-
-void AddNodesRequest::setPeriodUnit(const std::string &periodUnit) {
-  periodUnit_ = periodUnit;
-  setParameter(std::string("PeriodUnit"), periodUnit);
-}
-
-bool AddNodesRequest::getComputeEnableHt() const {
-  return computeEnableHt_;
-}
-
-void AddNodesRequest::setComputeEnableHt(bool computeEnableHt) {
-  computeEnableHt_ = computeEnableHt;
-  setParameter(std::string("ComputeEnableHt"), computeEnableHt ? "true" : "false");
-}
-
-std::string AddNodesRequest::getAutoRenew() const {
-  return autoRenew_;
-}
-
-void AddNodesRequest::setAutoRenew(const std::string &autoRenew) {
-  autoRenew_ = autoRenew;
-  setParameter(std::string("AutoRenew"), autoRenew);
-}
-
 std::string AddNodesRequest::getEcsChargeType() const {
   return ecsChargeType_;
 }
@@ -304,39 +349,3 @@ void AddNodesRequest::setEcsChargeType(const std::string &ecsChargeType) {
   setParameter(std::string("EcsChargeType"), ecsChargeType);
 }
 
-std::string AddNodesRequest::getInternetChargeType() const {
-  return internetChargeType_;
-}
-
-void AddNodesRequest::setInternetChargeType(const std::string &internetChargeType) {
-  internetChargeType_ = internetChargeType;
-  setParameter(std::string("InternetChargeType"), internetChargeType);
-}
-
-std::string AddNodesRequest::getCreateMode() const {
-  return createMode_;
-}
-
-void AddNodesRequest::setCreateMode(const std::string &createMode) {
-  createMode_ = createMode;
-  setParameter(std::string("CreateMode"), createMode);
-}
-
-std::string AddNodesRequest::getZoneId() const {
-  return zoneId_;
-}
-
-void AddNodesRequest::setZoneId(const std::string &zoneId) {
-  zoneId_ = zoneId;
-  setParameter(std::string("ZoneId"), zoneId);
-}
-
-int AddNodesRequest::getInternetMaxBandWidthIn() const {
-  return internetMaxBandWidthIn_;
-}
-
-void AddNodesRequest::setInternetMaxBandWidthIn(int internetMaxBandWidthIn) {
-  internetMaxBandWidthIn_ = internetMaxBandWidthIn;
-  setParameter(std::string("InternetMaxBandWidthIn"), std::to_string(internetMaxBandWidthIn));
-}
-

ehpc/src/model/AddQueueRequest.cc

@@ -25,6 +25,15 @@ AddQueueRequest::AddQueueRequest()
 
 AddQueueRequest::~AddQueueRequest() {}
 
+std::string AddQueueRequest::getDeploymentSetId() const {
+  return deploymentSetId_;
+}
+
+void AddQueueRequest::setDeploymentSetId(const std::string &deploymentSetId) {
+  deploymentSetId_ = deploymentSetId;
+  setParameter(std::string("DeploymentSetId"), deploymentSetId);
+}
+
 std::string AddQueueRequest::getQueueName() const {
   return queueName_;
 }
@@ -43,6 +52,15 @@ void AddQueueRequest::setClusterId(const std::string &clusterId) {
   setParameter(std::string("ClusterId"), clusterId);
 }
 
+std::string AddQueueRequest::getNetworkInterfaceTrafficMode() const {
+  return networkInterfaceTrafficMode_;
+}
+
+void AddQueueRequest::setNetworkInterfaceTrafficMode(const std::string &networkInterfaceTrafficMode) {
+  networkInterfaceTrafficMode_ = networkInterfaceTrafficMode;
+  setParameter(std::string("NetworkInterfaceTrafficMode"), networkInterfaceTrafficMode);
+}
+
 std::string AddQueueRequest::getAccessKeyId() const {
   return accessKeyId_;
 }

ehpc/src/model/CreateClusterRequest.cc

@@ -51,6 +51,25 @@ void CreateClusterRequest::setAdditionalVolumes(const std::vector<CreateClusterR
   }
 }
 
+std::vector<CreateClusterRequest::AddOns> CreateClusterRequest::getAddOns() const {
+  return addOns_;
+}
+
+void CreateClusterRequest::setAddOns(const std::vector<CreateClusterRequest::AddOns> &addOns) {
+  addOns_ = addOns;
+  for(int dep1 = 0; dep1 != addOns.size(); dep1++) {
+  auto addOnsObj = addOns.at(dep1);
+  std::string addOnsObjStr = std::string("AddOns") + "." + std::to_string(dep1 + 1);
+    setParameter(addOnsObjStr + ".DeployMode", addOnsObj.deployMode);
+    setParameter(addOnsObjStr + ".Port", std::to_string(addOnsObj.port));
+    setParameter(addOnsObjStr + ".ConfigFile", addOnsObj.configFile);
+    setParameter(addOnsObjStr + ".DefaultStart", addOnsObj.defaultStart ? "true" : "false");
+    setParameter(addOnsObjStr + ".Name", addOnsObj.name);
+    setParameter(addOnsObjStr + ".DBType", addOnsObj.dBType);
+    setParameter(addOnsObjStr + ".Version", addOnsObj.version);
+  }
+}
+
 std::string CreateClusterRequest::getEcsOrderManagerInstanceType() const {
   return ecsOrderManagerInstanceType_;
 }
@@ -78,6 +97,15 @@ void CreateClusterRequest::setSecurityGroupName(const std::string &securityGroup
   setParameter(std::string("SecurityGroupName"), securityGroupName);
 }
 
+bool CreateClusterRequest::getWithoutNas() const {
+  return withoutNas_;
+}
+
+void CreateClusterRequest::setWithoutNas(bool withoutNas) {
+  withoutNas_ = withoutNas;
+  setParameter(std::string("WithoutNas"), withoutNas ? "true" : "false");
+}
+
 std::string CreateClusterRequest::getImageOwnerAlias() const {
   return imageOwnerAlias_;
 }
@@ -447,6 +475,15 @@ void CreateClusterRequest::setSystemDiskType(const std::string &systemDiskType)
   setParameter(std::string("SystemDiskType"), systemDiskType);
 }
 
+std::string CreateClusterRequest::getDeploymentSetId() const {
+  return deploymentSetId_;
+}
+
+void CreateClusterRequest::setDeploymentSetId(const std::string &deploymentSetId) {
+  deploymentSetId_ = deploymentSetId;
+  setParameter(std::string("DeploymentSetId"), deploymentSetId);
+}
+
 std::string CreateClusterRequest::getVolumeProtocol() const {
   return volumeProtocol_;
 }

ehpc/src/model/CreateHybridClusterRequest.cc

@@ -97,6 +97,15 @@ void CreateHybridClusterRequest::setPassword(const std::string &password) {
   setParameter(std::string("Password"), password);
 }
 
+std::string CreateHybridClusterRequest::getHybridClusterOpMode() const {
+  return hybridClusterOpMode_;
+}
+
+void CreateHybridClusterRequest::setHybridClusterOpMode(const std::string &hybridClusterOpMode) {
+  hybridClusterOpMode_ = hybridClusterOpMode;
+  setParameter(std::string("HybridClusterOpMode"), hybridClusterOpMode);
+}
+
 CreateHybridClusterRequest::WinAdPar CreateHybridClusterRequest::getWinAdPar() const {
   return winAdPar_;
 }
@@ -264,6 +273,7 @@ CreateHybridClusterRequest::OpenldapPar CreateHybridClusterRequest::getOpenldapP
 
 void CreateHybridClusterRequest::setOpenldapPar(const CreateHybridClusterRequest::OpenldapPar &openldapPar) {
   openldapPar_ = openldapPar;
+  setParameter(std::string("OpenldapPar") + ".FallbackHomeDir", openldapPar.fallbackHomeDir);
   setParameter(std::string("OpenldapPar") + ".BaseDn", openldapPar.baseDn);
   setParameter(std::string("OpenldapPar") + ".LdapServerIp", openldapPar.ldapServerIp);
 }

ehpc/src/model/DescribeClusterResult.cc

@@ -96,10 +96,40 @@ void DescribeClusterResult::parse(const std::string &payload)
 		clusterInfo_.id = clusterInfoNode["Id"].asString();
 	if(!clusterInfoNode["ClientVersion"].isNull())
 		clusterInfo_.clientVersion = clusterInfoNode["ClientVersion"].asString();
+	if(!clusterInfoNode["ZoneId"].isNull())
+		clusterInfo_.zoneId = clusterInfoNode["ZoneId"].asString();
+	if(!clusterInfoNode["ResourceGroupId"].isNull())
+		clusterInfo_.resourceGroupId = clusterInfoNode["ResourceGroupId"].asString();
 	if(!clusterInfoNode["RamRoleName"].isNull())
 		clusterInfo_.ramRoleName = clusterInfoNode["RamRoleName"].asString();
 	if(!clusterInfoNode["RamNodeTypes"].isNull())
 		clusterInfo_.ramNodeTypes = clusterInfoNode["RamNodeTypes"].asString();
+	if(!clusterInfoNode["ClusterVersion"].isNull())
+		clusterInfo_.clusterVersion = clusterInfoNode["ClusterVersion"].asString();
+	if(!clusterInfoNode["WithoutAgent"].isNull())
+		clusterInfo_.withoutAgent = std::stoi(clusterInfoNode["WithoutAgent"].asString());
+	if(!clusterInfoNode["Plugin"].isNull())
+		clusterInfo_.plugin = clusterInfoNode["Plugin"].asString();
+	if(!clusterInfoNode["SchedulerPreInstall"].isNull())
+		clusterInfo_.schedulerPreInstall = std::stoi(clusterInfoNode["SchedulerPreInstall"].asString());
+	if(!clusterInfoNode["Domain"].isNull())
+		clusterInfo_.domain = clusterInfoNode["Domain"].asString();
+	if(!clusterInfoNode["OpenldapPar"].isNull())
+		clusterInfo_.openldapPar = clusterInfoNode["OpenldapPar"].asString();
+	if(!clusterInfoNode["WinAdPar"].isNull())
+		clusterInfo_.winAdPar = clusterInfoNode["WinAdPar"].asString();
+	if(!clusterInfoNode["Period"].isNull())
+		clusterInfo_.period = clusterInfoNode["Period"].asString();
+	if(!clusterInfoNode["PeriodUnit"].isNull())
+		clusterInfo_.periodUnit = clusterInfoNode["PeriodUnit"].asString();
+	if(!clusterInfoNode["AutoRenewPeriod"].isNull())
+		clusterInfo_.autoRenewPeriod = clusterInfoNode["AutoRenewPeriod"].asString();
+	if(!clusterInfoNode["AutoRenew"].isNull())
+		clusterInfo_.autoRenew = clusterInfoNode["AutoRenew"].asString();
+	if(!clusterInfoNode["ComputeSpotStrategy"].isNull())
+		clusterInfo_.computeSpotStrategy = clusterInfoNode["ComputeSpotStrategy"].asString();
+	if(!clusterInfoNode["ComputeSpotPriceLimit"].isNull())
+		clusterInfo_.computeSpotPriceLimit = clusterInfoNode["ComputeSpotPriceLimit"].asString();
 	auto allApplicationsNode = clusterInfoNode["Applications"]["ApplicationInfo"];
 	for (auto clusterInfoNodeApplicationsApplicationInfo : allApplicationsNode)
 	{
@@ -134,6 +164,40 @@ void DescribeClusterResult::parse(const std::string &payload)
 			onPremiseInfoItemObject.iP = clusterInfoNodeOnPremiseInfoOnPremiseInfoItem["IP"].asString();
 		clusterInfo_.onPremiseInfo.push_back(onPremiseInfoItemObject);
 	}
+	auto allAddOnsInfoNode = clusterInfoNode["AddOnsInfo"]["AddOnsInfoItem"];
+	for (auto clusterInfoNodeAddOnsInfoAddOnsInfoItem : allAddOnsInfoNode)
+	{
+		ClusterInfo::AddOnsInfoItem addOnsInfoItemObject;
+		if(!clusterInfoNodeAddOnsInfoAddOnsInfoItem["SoftwareId"].isNull())
+			addOnsInfoItemObject.softwareId = clusterInfoNodeAddOnsInfoAddOnsInfoItem["SoftwareId"].asString();
+		if(!clusterInfoNodeAddOnsInfoAddOnsInfoItem["DeployMode"].isNull())
+			addOnsInfoItemObject.deployMode = clusterInfoNodeAddOnsInfoAddOnsInfoItem["DeployMode"].asString();
+		if(!clusterInfoNodeAddOnsInfoAddOnsInfoItem["Port"].isNull())
+			addOnsInfoItemObject.port = std::stoi(clusterInfoNodeAddOnsInfoAddOnsInfoItem["Port"].asString());
+		if(!clusterInfoNodeAddOnsInfoAddOnsInfoItem["Status"].isNull())
+			addOnsInfoItemObject.status = clusterInfoNodeAddOnsInfoAddOnsInfoItem["Status"].asString();
+		if(!clusterInfoNodeAddOnsInfoAddOnsInfoItem["URL"].isNull())
+			addOnsInfoItemObject.uRL = clusterInfoNodeAddOnsInfoAddOnsInfoItem["URL"].asString();
+		clusterInfo_.addOnsInfo.push_back(addOnsInfoItemObject);
+	}
+	auto allNodesNode = clusterInfoNode["Nodes"]["NodesInfo"];
+	for (auto clusterInfoNodeNodesNodesInfo : allNodesNode)
+	{
+		ClusterInfo::NodesInfo nodesInfoObject;
+		if(!clusterInfoNodeNodesNodesInfo["Role"].isNull())
+			nodesInfoObject.role = clusterInfoNodeNodesNodesInfo["Role"].asString();
+		if(!clusterInfoNodeNodesNodesInfo["HostName"].isNull())
+			nodesInfoObject.hostName = clusterInfoNodeNodesNodesInfo["HostName"].asString();
+		if(!clusterInfoNodeNodesNodesInfo["IpAddress"].isNull())
+			nodesInfoObject.ipAddress = clusterInfoNodeNodesNodesInfo["IpAddress"].asString();
+		if(!clusterInfoNodeNodesNodesInfo["AccountType"].isNull())
+			nodesInfoObject.accountType = clusterInfoNodeNodesNodesInfo["AccountType"].asString();
+		if(!clusterInfoNodeNodesNodesInfo["Dir"].isNull())
+			nodesInfoObject.dir = clusterInfoNodeNodesNodesInfo["Dir"].asString();
+		if(!clusterInfoNodeNodesNodesInfo["SchedulerType"].isNull())
+			nodesInfoObject.schedulerType = clusterInfoNodeNodesNodesInfo["SchedulerType"].asString();
+		clusterInfo_.nodes.push_back(nodesInfoObject);
+	}
 	auto ecsInfoNode = clusterInfoNode["EcsInfo"];
 	auto managerNode = ecsInfoNode["Manager"];
 	if(!managerNode["InstanceType"].isNull())
@@ -155,6 +219,13 @@ void DescribeClusterResult::parse(const std::string &payload)
 		clusterInfo_.ecsInfo.proxyMgr.instanceType = proxyMgrNode["InstanceType"].asString();
 	if(!proxyMgrNode["Count"].isNull())
 		clusterInfo_.ecsInfo.proxyMgr.count = std::stoi(proxyMgrNode["Count"].asString());
+	auto initialImageNode = clusterInfoNode["InitialImage"];
+	if(!initialImageNode["OsTag"].isNull())
+		clusterInfo_.initialImage.osTag = initialImageNode["OsTag"].asString();
+	if(!initialImageNode["ImageOwnerAlias"].isNull())
+		clusterInfo_.initialImage.imageOwnerAlias = initialImageNode["ImageOwnerAlias"].asString();
+	if(!initialImageNode["ImageId"].isNull())
+		clusterInfo_.initialImage.imageId = initialImageNode["ImageId"].asString();
 
 }
 

ehpc/src/model/DescribeServerlessJobsRequest.cc

@@ -0,0 +1,56 @@
+/*
+ * 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/ehpc/model/DescribeServerlessJobsRequest.h>
+
+using AlibabaCloud::EHPC::Model::DescribeServerlessJobsRequest;
+
+DescribeServerlessJobsRequest::DescribeServerlessJobsRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DescribeServerlessJobs") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeServerlessJobsRequest::~DescribeServerlessJobsRequest() {}
+
+std::string DescribeServerlessJobsRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DescribeServerlessJobsRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string DescribeServerlessJobsRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeServerlessJobsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::vector<DescribeServerlessJobsRequest::std::string> DescribeServerlessJobsRequest::getJobIds() const {
+  return jobIds_;
+}
+
+void DescribeServerlessJobsRequest::setJobIds(const std::vector<DescribeServerlessJobsRequest::std::string> &jobIds) {
+  jobIds_ = jobIds;
+  for(int dep1 = 0; dep1 != jobIds.size(); dep1++) {
+    setParameter(std::string("JobIds") + "." + std::to_string(dep1 + 1), jobIds[dep1]);
+  }
+}
+

ehpc/src/model/DescribeServerlessJobsResult.cc

@@ -0,0 +1,548 @@
+/*
+ * 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/ehpc/model/DescribeServerlessJobsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+DescribeServerlessJobsResult::DescribeServerlessJobsResult() :
+	ServiceResult()
+{}
+
+DescribeServerlessJobsResult::DescribeServerlessJobsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeServerlessJobsResult::~DescribeServerlessJobsResult()
+{}
+
+void DescribeServerlessJobsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allJobInfosNode = value["JobInfos"]["JobInfo"];
+	for (auto valueJobInfosJobInfo : allJobInfosNode)
+	{
+		JobInfo jobInfosObject;
+		if(!valueJobInfosJobInfo["EndTime"].isNull())
+			jobInfosObject.endTime = std::stol(valueJobInfosJobInfo["EndTime"].asString());
+		if(!valueJobInfosJobInfo["Id"].isNull())
+			jobInfosObject.id = valueJobInfosJobInfo["Id"].asString();
+		if(!valueJobInfosJobInfo["IsArrayJob"].isNull())
+			jobInfosObject.isArrayJob = valueJobInfosJobInfo["IsArrayJob"].asString() == "true";
+		if(!valueJobInfosJobInfo["LastModifyTime"].isNull())
+			jobInfosObject.lastModifyTime = std::stol(valueJobInfosJobInfo["LastModifyTime"].asString());
+		if(!valueJobInfosJobInfo["Name"].isNull())
+			jobInfosObject.name = valueJobInfosJobInfo["Name"].asString();
+		if(!valueJobInfosJobInfo["Owner"].isNull())
+			jobInfosObject.owner = valueJobInfosJobInfo["Owner"].asString();
+		if(!valueJobInfosJobInfo["Priority"].isNull())
+			jobInfosObject.priority = std::stol(valueJobInfosJobInfo["Priority"].asString());
+		if(!valueJobInfosJobInfo["Queue"].isNull())
+			jobInfosObject.queue = valueJobInfosJobInfo["Queue"].asString();
+		if(!valueJobInfosJobInfo["StartTime"].isNull())
+			jobInfosObject.startTime = std::stol(valueJobInfosJobInfo["StartTime"].asString());
+		if(!valueJobInfosJobInfo["State"].isNull())
+			jobInfosObject.state = valueJobInfosJobInfo["State"].asString();
+		if(!valueJobInfosJobInfo["SubmitTime"].isNull())
+			jobInfosObject.submitTime = std::stol(valueJobInfosJobInfo["SubmitTime"].asString());
+		auto allContainerGroupsNode = valueJobInfosJobInfo["ContainerGroups"]["ContainerGroup"];
+		for (auto valueJobInfosJobInfoContainerGroupsContainerGroup : allContainerGroupsNode)
+		{
+			JobInfo::ContainerGroup containerGroupsObject;
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["ContainerGroupId"].isNull())
+				containerGroupsObject.containerGroupId = valueJobInfosJobInfoContainerGroupsContainerGroup["ContainerGroupId"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["ContainerGroupName"].isNull())
+				containerGroupsObject.containerGroupName = valueJobInfosJobInfoContainerGroupsContainerGroup["ContainerGroupName"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["Cpu"].isNull())
+				containerGroupsObject.cpu = std::stof(valueJobInfosJobInfoContainerGroupsContainerGroup["Cpu"].asString());
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["CreationTime"].isNull())
+				containerGroupsObject.creationTime = valueJobInfosJobInfoContainerGroupsContainerGroup["CreationTime"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["Discount"].isNull())
+				containerGroupsObject.discount = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroup["Discount"].asString());
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["EniInstanceId"].isNull())
+				containerGroupsObject.eniInstanceId = valueJobInfosJobInfoContainerGroupsContainerGroup["EniInstanceId"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["EphemeralStorage"].isNull())
+				containerGroupsObject.ephemeralStorage = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroup["EphemeralStorage"].asString());
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["ExpiredTime"].isNull())
+				containerGroupsObject.expiredTime = valueJobInfosJobInfoContainerGroupsContainerGroup["ExpiredTime"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["FailedTime"].isNull())
+				containerGroupsObject.failedTime = valueJobInfosJobInfoContainerGroupsContainerGroup["FailedTime"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["InstanceType"].isNull())
+				containerGroupsObject.instanceType = valueJobInfosJobInfoContainerGroupsContainerGroup["InstanceType"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["InternetIp"].isNull())
+				containerGroupsObject.internetIp = valueJobInfosJobInfoContainerGroupsContainerGroup["InternetIp"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["IntranetIp"].isNull())
+				containerGroupsObject.intranetIp = valueJobInfosJobInfoContainerGroupsContainerGroup["IntranetIp"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["Ipv6Address"].isNull())
+				containerGroupsObject.ipv6Address = valueJobInfosJobInfoContainerGroupsContainerGroup["Ipv6Address"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["Memory"].isNull())
+				containerGroupsObject.memory = std::stof(valueJobInfosJobInfoContainerGroupsContainerGroup["Memory"].asString());
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["RamRoleName"].isNull())
+				containerGroupsObject.ramRoleName = valueJobInfosJobInfoContainerGroupsContainerGroup["RamRoleName"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["RegionId"].isNull())
+				containerGroupsObject.regionId = valueJobInfosJobInfoContainerGroupsContainerGroup["RegionId"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["ResourceGroupId"].isNull())
+				containerGroupsObject.resourceGroupId = valueJobInfosJobInfoContainerGroupsContainerGroup["ResourceGroupId"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["RestartPolicy"].isNull())
+				containerGroupsObject.restartPolicy = valueJobInfosJobInfoContainerGroupsContainerGroup["RestartPolicy"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["SecurityGroupId"].isNull())
+				containerGroupsObject.securityGroupId = valueJobInfosJobInfoContainerGroupsContainerGroup["SecurityGroupId"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["SpotPriceLimit"].isNull())
+				containerGroupsObject.spotPriceLimit = std::stof(valueJobInfosJobInfoContainerGroupsContainerGroup["SpotPriceLimit"].asString());
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["SpotStrategy"].isNull())
+				containerGroupsObject.spotStrategy = valueJobInfosJobInfoContainerGroupsContainerGroup["SpotStrategy"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["Status"].isNull())
+				containerGroupsObject.status = valueJobInfosJobInfoContainerGroupsContainerGroup["Status"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["SucceededTime"].isNull())
+				containerGroupsObject.succeededTime = valueJobInfosJobInfoContainerGroupsContainerGroup["SucceededTime"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["TenantEniInstanceId"].isNull())
+				containerGroupsObject.tenantEniInstanceId = valueJobInfosJobInfoContainerGroupsContainerGroup["TenantEniInstanceId"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["TenantEniIp"].isNull())
+				containerGroupsObject.tenantEniIp = valueJobInfosJobInfoContainerGroupsContainerGroup["TenantEniIp"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["TenantSecurityGroupId"].isNull())
+				containerGroupsObject.tenantSecurityGroupId = valueJobInfosJobInfoContainerGroupsContainerGroup["TenantSecurityGroupId"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["TenantVSwitchId"].isNull())
+				containerGroupsObject.tenantVSwitchId = valueJobInfosJobInfoContainerGroupsContainerGroup["TenantVSwitchId"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["VSwitchId"].isNull())
+				containerGroupsObject.vSwitchId = valueJobInfosJobInfoContainerGroupsContainerGroup["VSwitchId"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["VpcId"].isNull())
+				containerGroupsObject.vpcId = valueJobInfosJobInfoContainerGroupsContainerGroup["VpcId"].asString();
+			if(!valueJobInfosJobInfoContainerGroupsContainerGroup["ZoneId"].isNull())
+				containerGroupsObject.zoneId = valueJobInfosJobInfoContainerGroupsContainerGroup["ZoneId"].asString();
+			auto allContainersNode = valueJobInfosJobInfoContainerGroupsContainerGroup["Containers"]["Container"];
+			for (auto valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer : allContainersNode)
+			{
+				JobInfo::ContainerGroup::Container containersObject;
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Cpu"].isNull())
+					containersObject.cpu = std::stof(valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Cpu"].asString());
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Gpu"].isNull())
+					containersObject.gpu = std::stoi(valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Gpu"].asString());
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Image"].isNull())
+					containersObject.image = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Image"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["ImagePullPolicy"].isNull())
+					containersObject.imagePullPolicy = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["ImagePullPolicy"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Memory"].isNull())
+					containersObject.memory = std::stof(valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Memory"].asString());
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Name"].isNull())
+					containersObject.name = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Name"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Ready"].isNull())
+					containersObject.ready = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Ready"].asString() == "true";
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["RestartCount"].isNull())
+					containersObject.restartCount = std::stoi(valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["RestartCount"].asString());
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Stdin"].isNull())
+					containersObject.stdin = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Stdin"].asString() == "true";
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["StdinOnce"].isNull())
+					containersObject.stdinOnce = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["StdinOnce"].asString() == "true";
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Tty"].isNull())
+					containersObject.tty = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Tty"].asString() == "true";
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["WorkingDir"].isNull())
+					containersObject.workingDir = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["WorkingDir"].asString();
+				auto allEnvironmentVarsNode = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["EnvironmentVars"]["EnvironmentVar"];
+				for (auto valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerEnvironmentVarsEnvironmentVar : allEnvironmentVarsNode)
+				{
+					JobInfo::ContainerGroup::Container::EnvironmentVar environmentVarsObject;
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerEnvironmentVarsEnvironmentVar["Key"].isNull())
+						environmentVarsObject.key = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerEnvironmentVarsEnvironmentVar["Key"].asString();
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerEnvironmentVarsEnvironmentVar["Value"].isNull())
+						environmentVarsObject.value = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerEnvironmentVarsEnvironmentVar["Value"].asString();
+					auto valueFromNode = value["ValueFrom"];
+					auto fieldRefNode = valueFromNode["FieldRef"];
+					if(!fieldRefNode["FieldPath"].isNull())
+						environmentVarsObject.valueFrom.fieldRef.fieldPath = fieldRefNode["FieldPath"].asString();
+					containersObject.environmentVars.push_back(environmentVarsObject);
+				}
+				auto allPortsNode = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Ports"]["Port"];
+				for (auto valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerPortsPort : allPortsNode)
+				{
+					JobInfo::ContainerGroup::Container::Port portsObject;
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerPortsPort["Port"].isNull())
+						portsObject.port = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerPortsPort["Port"].asString());
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerPortsPort["Protocol"].isNull())
+						portsObject.protocol = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerPortsPort["Protocol"].asString();
+					containersObject.ports.push_back(portsObject);
+				}
+				auto allVolumeMountsNode = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["VolumeMounts"]["VolumeMount"];
+				for (auto valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount : allVolumeMountsNode)
+				{
+					JobInfo::ContainerGroup::Container::VolumeMount volumeMountsObject;
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["MountPath"].isNull())
+						volumeMountsObject.mountPath = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["MountPath"].asString();
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["MountPropagation"].isNull())
+						volumeMountsObject.mountPropagation = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["MountPropagation"].asString();
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["Name"].isNull())
+						volumeMountsObject.name = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["Name"].asString();
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["ReadOnly"].isNull())
+						volumeMountsObject.readOnly = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["ReadOnly"].asString() == "true";
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["SubPath"].isNull())
+						volumeMountsObject.subPath = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["SubPath"].asString();
+					containersObject.volumeMounts.push_back(volumeMountsObject);
+				}
+				auto currentStateNode = value["CurrentState"];
+				if(!currentStateNode["DetailStatus"].isNull())
+					containersObject.currentState.detailStatus = currentStateNode["DetailStatus"].asString();
+				if(!currentStateNode["ExitCode"].isNull())
+					containersObject.currentState.exitCode = std::stol(currentStateNode["ExitCode"].asString());
+				if(!currentStateNode["FinishTime"].isNull())
+					containersObject.currentState.finishTime = currentStateNode["FinishTime"].asString();
+				if(!currentStateNode["Message"].isNull())
+					containersObject.currentState.message = currentStateNode["Message"].asString();
+				if(!currentStateNode["Reason"].isNull())
+					containersObject.currentState.reason = currentStateNode["Reason"].asString();
+				if(!currentStateNode["Signal"].isNull())
+					containersObject.currentState.signal = std::stol(currentStateNode["Signal"].asString());
+				if(!currentStateNode["StartTime"].isNull())
+					containersObject.currentState.startTime = currentStateNode["StartTime"].asString();
+				if(!currentStateNode["State"].isNull())
+					containersObject.currentState.state = currentStateNode["State"].asString();
+				auto livenessProbeNode = value["LivenessProbe"];
+				if(!livenessProbeNode["FailureThreshold"].isNull())
+					containersObject.livenessProbe.failureThreshold = std::stol(livenessProbeNode["FailureThreshold"].asString());
+				if(!livenessProbeNode["InitialDelaySeconds"].isNull())
+					containersObject.livenessProbe.initialDelaySeconds = std::stol(livenessProbeNode["InitialDelaySeconds"].asString());
+				if(!livenessProbeNode["PeriodSeconds"].isNull())
+					containersObject.livenessProbe.periodSeconds = std::stol(livenessProbeNode["PeriodSeconds"].asString());
+				if(!livenessProbeNode["SuccessThreshold"].isNull())
+					containersObject.livenessProbe.successThreshold = std::stol(livenessProbeNode["SuccessThreshold"].asString());
+				if(!livenessProbeNode["TimeoutSeconds"].isNull())
+					containersObject.livenessProbe.timeoutSeconds = std::stol(livenessProbeNode["TimeoutSeconds"].asString());
+				auto httpGetNode = livenessProbeNode["HttpGet"];
+				if(!httpGetNode["Path"].isNull())
+					containersObject.livenessProbe.httpGet.path = httpGetNode["Path"].asString();
+				if(!httpGetNode["Port"].isNull())
+					containersObject.livenessProbe.httpGet.port = std::stol(httpGetNode["Port"].asString());
+				if(!httpGetNode["Scheme"].isNull())
+					containersObject.livenessProbe.httpGet.scheme = httpGetNode["Scheme"].asString();
+				auto tcpSocketNode = livenessProbeNode["TcpSocket"];
+				if(!tcpSocketNode["Host"].isNull())
+					containersObject.livenessProbe.tcpSocket.host = tcpSocketNode["Host"].asString();
+				if(!tcpSocketNode["Port"].isNull())
+					containersObject.livenessProbe.tcpSocket.port = std::stol(tcpSocketNode["Port"].asString());
+					auto allExecs = livenessProbeNode["Execs"]["Exec"];
+					for (auto value : allExecs)
+						containersObject.livenessProbe.execs.push_back(value.asString());
+				auto previousStateNode = value["PreviousState"];
+				if(!previousStateNode["DetailStatus"].isNull())
+					containersObject.previousState.detailStatus = previousStateNode["DetailStatus"].asString();
+				if(!previousStateNode["ExitCode"].isNull())
+					containersObject.previousState.exitCode = std::stol(previousStateNode["ExitCode"].asString());
+				if(!previousStateNode["FinishTime"].isNull())
+					containersObject.previousState.finishTime = previousStateNode["FinishTime"].asString();
+				if(!previousStateNode["Message"].isNull())
+					containersObject.previousState.message = previousStateNode["Message"].asString();
+				if(!previousStateNode["Reason"].isNull())
+					containersObject.previousState.reason = previousStateNode["Reason"].asString();
+				if(!previousStateNode["Signal"].isNull())
+					containersObject.previousState.signal = std::stol(previousStateNode["Signal"].asString());
+				if(!previousStateNode["StartTime"].isNull())
+					containersObject.previousState.startTime = previousStateNode["StartTime"].asString();
+				if(!previousStateNode["State"].isNull())
+					containersObject.previousState.state = previousStateNode["State"].asString();
+				auto readinessProbeNode = value["ReadinessProbe"];
+				if(!readinessProbeNode["FailureThreshold"].isNull())
+					containersObject.readinessProbe.failureThreshold = std::stol(readinessProbeNode["FailureThreshold"].asString());
+				if(!readinessProbeNode["InitialDelaySeconds"].isNull())
+					containersObject.readinessProbe.initialDelaySeconds = std::stol(readinessProbeNode["InitialDelaySeconds"].asString());
+				if(!readinessProbeNode["PeriodSeconds"].isNull())
+					containersObject.readinessProbe.periodSeconds = std::stol(readinessProbeNode["PeriodSeconds"].asString());
+				if(!readinessProbeNode["SuccessThreshold"].isNull())
+					containersObject.readinessProbe.successThreshold = std::stol(readinessProbeNode["SuccessThreshold"].asString());
+				if(!readinessProbeNode["TimeoutSeconds"].isNull())
+					containersObject.readinessProbe.timeoutSeconds = std::stol(readinessProbeNode["TimeoutSeconds"].asString());
+				auto httpGet2Node = readinessProbeNode["HttpGet"];
+				if(!httpGet2Node["Path"].isNull())
+					containersObject.readinessProbe.httpGet2.path = httpGet2Node["Path"].asString();
+				if(!httpGet2Node["Port"].isNull())
+					containersObject.readinessProbe.httpGet2.port = std::stol(httpGet2Node["Port"].asString());
+				if(!httpGet2Node["Scheme"].isNull())
+					containersObject.readinessProbe.httpGet2.scheme = httpGet2Node["Scheme"].asString();
+				auto tcpSocket3Node = readinessProbeNode["TcpSocket"];
+				if(!tcpSocket3Node["Host"].isNull())
+					containersObject.readinessProbe.tcpSocket3.host = tcpSocket3Node["Host"].asString();
+				if(!tcpSocket3Node["Port"].isNull())
+					containersObject.readinessProbe.tcpSocket3.port = std::stol(tcpSocket3Node["Port"].asString());
+					auto allExecs1 = readinessProbeNode["Execs"]["Exec"];
+					for (auto value : allExecs1)
+						containersObject.readinessProbe.execs1.push_back(value.asString());
+				auto securityContextNode = value["SecurityContext"];
+				if(!securityContextNode["ReadOnlyRootFilesystem"].isNull())
+					containersObject.securityContext.readOnlyRootFilesystem = securityContextNode["ReadOnlyRootFilesystem"].asString() == "true";
+				if(!securityContextNode["RunAsUser"].isNull())
+					containersObject.securityContext.runAsUser = std::stol(securityContextNode["RunAsUser"].asString());
+				auto capabilityNode = securityContextNode["Capability"];
+					auto allAdds = capabilityNode["Adds"]["Add"];
+					for (auto value : allAdds)
+						containersObject.securityContext.capability.adds.push_back(value.asString());
+				auto allArgs = value["Args"]["Arg"];
+				for (auto value : allArgs)
+					containersObject.args.push_back(value.asString());
+				auto allCommands = value["Commands"]["Command"];
+				for (auto value : allCommands)
+					containersObject.commands.push_back(value.asString());
+				containerGroupsObject.containers.push_back(containersObject);
+			}
+			auto allEventsNode = valueJobInfosJobInfoContainerGroupsContainerGroup["Events"]["Event"];
+			for (auto valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent : allEventsNode)
+			{
+				JobInfo::ContainerGroup::Event eventsObject;
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Count"].isNull())
+					eventsObject.count = std::stoi(valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Count"].asString());
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["FirstTimestamp"].isNull())
+					eventsObject.firstTimestamp = valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["FirstTimestamp"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["LastTimestamp"].isNull())
+					eventsObject.lastTimestamp = valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["LastTimestamp"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Message"].isNull())
+					eventsObject.message = valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Message"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Name"].isNull())
+					eventsObject.name = valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Name"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Reason"].isNull())
+					eventsObject.reason = valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Reason"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Type"].isNull())
+					eventsObject.type = valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Type"].asString();
+				containerGroupsObject.events.push_back(eventsObject);
+			}
+			auto allHostAliasesNode = valueJobInfosJobInfoContainerGroupsContainerGroup["HostAliases"]["HostAlias"];
+			for (auto valueJobInfosJobInfoContainerGroupsContainerGroupHostAliasesHostAlias : allHostAliasesNode)
+			{
+				JobInfo::ContainerGroup::HostAlias hostAliasesObject;
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupHostAliasesHostAlias["Ip"].isNull())
+					hostAliasesObject.ip = valueJobInfosJobInfoContainerGroupsContainerGroupHostAliasesHostAlias["Ip"].asString();
+				auto allHostnames = value["Hostnames"]["Hostname"];
+				for (auto value : allHostnames)
+					hostAliasesObject.hostnames.push_back(value.asString());
+				containerGroupsObject.hostAliases.push_back(hostAliasesObject);
+			}
+			auto allInitContainersNode = valueJobInfosJobInfoContainerGroupsContainerGroup["InitContainers"]["InitContainer"];
+			for (auto valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer : allInitContainersNode)
+			{
+				JobInfo::ContainerGroup::InitContainer initContainersObject;
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Cpu"].isNull())
+					initContainersObject.cpu = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Cpu"].asString());
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Gpu"].isNull())
+					initContainersObject.gpu = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Gpu"].asString());
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Image"].isNull())
+					initContainersObject.image = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Image"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["ImagePullPolicy"].isNull())
+					initContainersObject.imagePullPolicy = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["ImagePullPolicy"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Memory"].isNull())
+					initContainersObject.memory = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Memory"].asString());
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Name"].isNull())
+					initContainersObject.name = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Name"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Ready"].isNull())
+					initContainersObject.ready = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Ready"].asString() == "true";
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["RestartCount"].isNull())
+					initContainersObject.restartCount = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["RestartCount"].asString());
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["WorkingDir"].isNull())
+					initContainersObject.workingDir = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["WorkingDir"].asString();
+				auto allEnvironmentVars8Node = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["EnvironmentVars"]["EnvironmentVar"];
+				for (auto valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerEnvironmentVarsEnvironmentVar : allEnvironmentVars8Node)
+				{
+					JobInfo::ContainerGroup::InitContainer::EnvironmentVar11 environmentVars8Object;
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerEnvironmentVarsEnvironmentVar["Key"].isNull())
+						environmentVars8Object.key = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerEnvironmentVarsEnvironmentVar["Key"].asString();
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerEnvironmentVarsEnvironmentVar["Value"].isNull())
+						environmentVars8Object.value = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerEnvironmentVarsEnvironmentVar["Value"].asString();
+					auto valueFrom12Node = value["ValueFrom"];
+					auto fieldRef13Node = valueFrom12Node["FieldRef"];
+					if(!fieldRef13Node["FieldPath"].isNull())
+						environmentVars8Object.valueFrom12.fieldRef13.fieldPath = fieldRef13Node["FieldPath"].asString();
+					initContainersObject.environmentVars8.push_back(environmentVars8Object);
+				}
+				auto allPorts9Node = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Ports"]["Port"];
+				for (auto valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerPortsPort : allPorts9Node)
+				{
+					JobInfo::ContainerGroup::InitContainer::Port14 ports9Object;
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerPortsPort["Port"].isNull())
+						ports9Object.port = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerPortsPort["Port"].asString());
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerPortsPort["Protocol"].isNull())
+						ports9Object.protocol = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerPortsPort["Protocol"].asString();
+					initContainersObject.ports9.push_back(ports9Object);
+				}
+				auto allVolumeMounts10Node = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["VolumeMounts"]["VolumeMount"];
+				for (auto valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount : allVolumeMounts10Node)
+				{
+					JobInfo::ContainerGroup::InitContainer::VolumeMount15 volumeMounts10Object;
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["MountPath"].isNull())
+						volumeMounts10Object.mountPath = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["MountPath"].asString();
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["MountPropagation"].isNull())
+						volumeMounts10Object.mountPropagation = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["MountPropagation"].asString();
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["Name"].isNull())
+						volumeMounts10Object.name = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["Name"].asString();
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["ReadOnly"].isNull())
+						volumeMounts10Object.readOnly = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["ReadOnly"].asString() == "true";
+					initContainersObject.volumeMounts10.push_back(volumeMounts10Object);
+				}
+				auto currentState5Node = value["CurrentState"];
+				if(!currentState5Node["DetailStatus"].isNull())
+					initContainersObject.currentState5.detailStatus = currentState5Node["DetailStatus"].asString();
+				if(!currentState5Node["ExitCode"].isNull())
+					initContainersObject.currentState5.exitCode = std::stol(currentState5Node["ExitCode"].asString());
+				if(!currentState5Node["FinishTime"].isNull())
+					initContainersObject.currentState5.finishTime = currentState5Node["FinishTime"].asString();
+				if(!currentState5Node["Message"].isNull())
+					initContainersObject.currentState5.message = currentState5Node["Message"].asString();
+				if(!currentState5Node["Reason"].isNull())
+					initContainersObject.currentState5.reason = currentState5Node["Reason"].asString();
+				if(!currentState5Node["Signal"].isNull())
+					initContainersObject.currentState5.signal = std::stol(currentState5Node["Signal"].asString());
+				if(!currentState5Node["StartTime"].isNull())
+					initContainersObject.currentState5.startTime = currentState5Node["StartTime"].asString();
+				if(!currentState5Node["State"].isNull())
+					initContainersObject.currentState5.state = currentState5Node["State"].asString();
+				auto previousState6Node = value["PreviousState"];
+				if(!previousState6Node["DetailStatus"].isNull())
+					initContainersObject.previousState6.detailStatus = previousState6Node["DetailStatus"].asString();
+				if(!previousState6Node["ExitCode"].isNull())
+					initContainersObject.previousState6.exitCode = std::stol(previousState6Node["ExitCode"].asString());
+				if(!previousState6Node["FinishTime"].isNull())
+					initContainersObject.previousState6.finishTime = previousState6Node["FinishTime"].asString();
+				if(!previousState6Node["Message"].isNull())
+					initContainersObject.previousState6.message = previousState6Node["Message"].asString();
+				if(!previousState6Node["Reason"].isNull())
+					initContainersObject.previousState6.reason = previousState6Node["Reason"].asString();
+				if(!previousState6Node["Signal"].isNull())
+					initContainersObject.previousState6.signal = std::stol(previousState6Node["Signal"].asString());
+				if(!previousState6Node["StartTime"].isNull())
+					initContainersObject.previousState6.startTime = previousState6Node["StartTime"].asString();
+				if(!previousState6Node["State"].isNull())
+					initContainersObject.previousState6.state = previousState6Node["State"].asString();
+				auto securityContext7Node = value["SecurityContext"];
+				if(!securityContext7Node["ReadOnlyRootFilesystem"].isNull())
+					initContainersObject.securityContext7.readOnlyRootFilesystem = securityContext7Node["ReadOnlyRootFilesystem"].asString() == "true";
+				if(!securityContext7Node["RunAsUser"].isNull())
+					initContainersObject.securityContext7.runAsUser = std::stol(securityContext7Node["RunAsUser"].asString());
+				auto capability16Node = securityContext7Node["Capability"];
+					auto allAdds17 = capability16Node["Adds"]["Add"];
+					for (auto value : allAdds17)
+						initContainersObject.securityContext7.capability16.adds17.push_back(value.asString());
+				auto allArgs4 = value["Args"]["Arg"];
+				for (auto value : allArgs4)
+					initContainersObject.args4.push_back(value.asString());
+				auto allCommand = value["Command"]["Command"];
+				for (auto value : allCommand)
+					initContainersObject.command.push_back(value.asString());
+				containerGroupsObject.initContainers.push_back(initContainersObject);
+			}
+			auto allTagsNode = valueJobInfosJobInfoContainerGroupsContainerGroup["Tags"]["Tag"];
+			for (auto valueJobInfosJobInfoContainerGroupsContainerGroupTagsTag : allTagsNode)
+			{
+				JobInfo::ContainerGroup::Tag tagsObject;
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupTagsTag["Key"].isNull())
+					tagsObject.key = valueJobInfosJobInfoContainerGroupsContainerGroupTagsTag["Key"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupTagsTag["Value"].isNull())
+					tagsObject.value = valueJobInfosJobInfoContainerGroupsContainerGroupTagsTag["Value"].asString();
+				containerGroupsObject.tags.push_back(tagsObject);
+			}
+			auto allVolumesNode = valueJobInfosJobInfoContainerGroupsContainerGroup["Volumes"]["Volume"];
+			for (auto valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume : allVolumesNode)
+			{
+				JobInfo::ContainerGroup::Volume volumesObject;
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["DiskVolumeDiskId"].isNull())
+					volumesObject.diskVolumeDiskId = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["DiskVolumeDiskId"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["DiskVolumeFsType"].isNull())
+					volumesObject.diskVolumeFsType = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["DiskVolumeFsType"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["EmptyDirVolumeMedium"].isNull())
+					volumesObject.emptyDirVolumeMedium = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["EmptyDirVolumeMedium"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["EmptyDirVolumeSizeLimit"].isNull())
+					volumesObject.emptyDirVolumeSizeLimit = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["EmptyDirVolumeSizeLimit"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["FlexVolumeDriver"].isNull())
+					volumesObject.flexVolumeDriver = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["FlexVolumeDriver"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["FlexVolumeFsType"].isNull())
+					volumesObject.flexVolumeFsType = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["FlexVolumeFsType"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["FlexVolumeOptions"].isNull())
+					volumesObject.flexVolumeOptions = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["FlexVolumeOptions"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["NFSVolumePath"].isNull())
+					volumesObject.nFSVolumePath = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["NFSVolumePath"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["NFSVolumeReadOnly"].isNull())
+					volumesObject.nFSVolumeReadOnly = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["NFSVolumeReadOnly"].asString() == "true";
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["NFSVolumeServer"].isNull())
+					volumesObject.nFSVolumeServer = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["NFSVolumeServer"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["Name"].isNull())
+					volumesObject.name = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["Name"].asString();
+				if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["Type"].isNull())
+					volumesObject.type = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["Type"].asString();
+				auto allConfigFileVolumeConfigFileToPathsNode = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["ConfigFileVolumeConfigFileToPaths"]["ConfigFileVolumeConfigFileToPath"];
+				for (auto valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolumeConfigFileVolumeConfigFileToPathsConfigFileVolumeConfigFileToPath : allConfigFileVolumeConfigFileToPathsNode)
+				{
+					JobInfo::ContainerGroup::Volume::ConfigFileVolumeConfigFileToPath configFileVolumeConfigFileToPathsObject;
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolumeConfigFileVolumeConfigFileToPathsConfigFileVolumeConfigFileToPath["Content"].isNull())
+						configFileVolumeConfigFileToPathsObject.content = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolumeConfigFileVolumeConfigFileToPathsConfigFileVolumeConfigFileToPath["Content"].asString();
+					if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolumeConfigFileVolumeConfigFileToPathsConfigFileVolumeConfigFileToPath["Path"].isNull())
+						configFileVolumeConfigFileToPathsObject.path = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolumeConfigFileVolumeConfigFileToPathsConfigFileVolumeConfigFileToPath["Path"].asString();
+					volumesObject.configFileVolumeConfigFileToPaths.push_back(configFileVolumeConfigFileToPathsObject);
+				}
+				containerGroupsObject.volumes.push_back(volumesObject);
+			}
+			auto dnsConfigNode = value["DnsConfig"];
+			auto allOptionsNode = dnsConfigNode["Options"]["Option"];
+			for (auto dnsConfigNodeOptionsOption : allOptionsNode)
+			{
+				JobInfo::ContainerGroup::DnsConfig::Option optionObject;
+				if(!dnsConfigNodeOptionsOption["Name"].isNull())
+					optionObject.name = dnsConfigNodeOptionsOption["Name"].asString();
+				if(!dnsConfigNodeOptionsOption["Value"].isNull())
+					optionObject.value = dnsConfigNodeOptionsOption["Value"].asString();
+				containerGroupsObject.dnsConfig.options.push_back(optionObject);
+			}
+				auto allNameServers = dnsConfigNode["NameServers"]["NameServer"];
+				for (auto value : allNameServers)
+					containerGroupsObject.dnsConfig.nameServers.push_back(value.asString());
+				auto allSearches = dnsConfigNode["Searches"]["Search"];
+				for (auto value : allSearches)
+					containerGroupsObject.dnsConfig.searches.push_back(value.asString());
+			auto eciSecurityContextNode = value["EciSecurityContext"];
+			auto allSysctlsNode = eciSecurityContextNode["Sysctls"]["Sysctl"];
+			for (auto eciSecurityContextNodeSysctlsSysctl : allSysctlsNode)
+			{
+				JobInfo::ContainerGroup::EciSecurityContext::Sysctl sysctlObject;
+				if(!eciSecurityContextNodeSysctlsSysctl["Name"].isNull())
+					sysctlObject.name = eciSecurityContextNodeSysctlsSysctl["Name"].asString();
+				if(!eciSecurityContextNodeSysctlsSysctl["Value"].isNull())
+					sysctlObject.value = eciSecurityContextNodeSysctlsSysctl["Value"].asString();
+				containerGroupsObject.eciSecurityContext.sysctls.push_back(sysctlObject);
+			}
+			jobInfosObject.containerGroups.push_back(containerGroupsObject);
+		}
+		auto arrayPropertiesNode = value["ArrayProperties"];
+		if(!arrayPropertiesNode["IndexStart"].isNull())
+			jobInfosObject.arrayProperties.indexStart = std::stol(arrayPropertiesNode["IndexStart"].asString());
+		if(!arrayPropertiesNode["IndexEnd"].isNull())
+			jobInfosObject.arrayProperties.indexEnd = std::stol(arrayPropertiesNode["IndexEnd"].asString());
+		if(!arrayPropertiesNode["IndexStep"].isNull())
+			jobInfosObject.arrayProperties.indexStep = std::stol(arrayPropertiesNode["IndexStep"].asString());
+		jobInfos_.push_back(jobInfosObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int DescribeServerlessJobsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::vector<DescribeServerlessJobsResult::JobInfo> DescribeServerlessJobsResult::getJobInfos()const
+{
+	return jobInfos_;
+}
+

ehpc/src/model/GetAutoScaleConfigResult.cc

@@ -77,6 +77,8 @@ void GetAutoScaleConfigResult::parse(const std::string &payload)
 			queuesObject.maxNodesPerCycle = std::stol(valueQueuesQueueInfo["MaxNodesPerCycle"].asString());
 		if(!valueQueuesQueueInfo["MinNodesPerCycle"].isNull())
 			queuesObject.minNodesPerCycle = std::stol(valueQueuesQueueInfo["MinNodesPerCycle"].asString());
+		if(!valueQueuesQueueInfo["SortedByInventory"].isNull())
+			queuesObject.sortedByInventory = valueQueuesQueueInfo["SortedByInventory"].asString() == "true";
 		auto allInstanceTypesNode = valueQueuesQueueInfo["InstanceTypes"]["InstanceTypeInfo"];
 		for (auto valueQueuesQueueInfoInstanceTypesInstanceTypeInfo : allInstanceTypesNode)
 		{
@@ -151,6 +153,10 @@ void GetAutoScaleConfigResult::parse(const std::string &payload)
 		clusterId_ = value["ClusterId"].asString();
 	if(!value["Uid"].isNull())
 		uid_ = value["Uid"].asString();
+	if(!value["ComputeEnableHt"].isNull())
+		computeEnableHt_ = value["ComputeEnableHt"].asString() == "true";
+	if(!value["DnsConfig"].isNull())
+		dnsConfig_ = value["DnsConfig"].asString();
 
 }
 
@@ -164,6 +170,11 @@ bool GetAutoScaleConfigResult::getEnableAutoGrow()const
 	return enableAutoGrow_;
 }
 
+bool GetAutoScaleConfigResult::getComputeEnableHt()const
+{
+	return computeEnableHt_;
+}
+
 std::string GetAutoScaleConfigResult::getClusterId()const
 {
 	return clusterId_;
@@ -209,6 +220,11 @@ int GetAutoScaleConfigResult::getGrowTimeoutInMinutes()const
 	return growTimeoutInMinutes_;
 }
 
+std::string GetAutoScaleConfigResult::getDnsConfig()const
+{
+	return dnsConfig_;
+}
+
 std::string GetAutoScaleConfigResult::getImageId()const
 {
 	return imageId_;

ehpc/src/model/ListClustersResult.cc

@@ -99,6 +99,8 @@ void ListClustersResult::parse(const std::string &payload)
 			clustersObject.location = valueClustersClusterInfoSimple["Location"].asString();
 		if(!valueClustersClusterInfoSimple["ClientVersion"].isNull())
 			clustersObject.clientVersion = valueClustersClusterInfoSimple["ClientVersion"].asString();
+		if(!valueClustersClusterInfoSimple["ResourceGroupId"].isNull())
+			clustersObject.resourceGroupId = valueClustersClusterInfoSimple["ResourceGroupId"].asString();
 		if(!valueClustersClusterInfoSimple["HasPlugin"].isNull())
 			clustersObject.hasPlugin = valueClustersClusterInfoSimple["HasPlugin"].asString() == "true";
 		auto managersNode = value["Managers"];

ehpc/src/model/ListQueuesResult.cc

@@ -59,6 +59,8 @@ void ListQueuesResult::parse(const std::string &payload)
 			queuesObject.hostNameSuffix = valueQueuesQueueInfo["HostNameSuffix"].asString();
 		if(!valueQueuesQueueInfo["SpotStrategy"].isNull())
 			queuesObject.spotStrategy = valueQueuesQueueInfo["SpotStrategy"].asString();
+		if(!valueQueuesQueueInfo["DeploymentSetId"].isNull())
+			queuesObject.deploymentSetId = valueQueuesQueueInfo["DeploymentSetId"].asString();
 		auto allSpotInstanceTypesNode = valueQueuesQueueInfo["SpotInstanceTypes"]["Instance"];
 		for (auto valueQueuesQueueInfoSpotInstanceTypesInstance : allSpotInstanceTypesNode)
 		{

ehpc/src/model/ListServerlessJobsRequest.cc

@@ -0,0 +1,152 @@
+/*
+ * 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/ehpc/model/ListServerlessJobsRequest.h>
+
+using AlibabaCloud::EHPC::Model::ListServerlessJobsRequest;
+
+ListServerlessJobsRequest::ListServerlessJobsRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "ListServerlessJobs") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListServerlessJobsRequest::~ListServerlessJobsRequest() {}
+
+std::string ListServerlessJobsRequest::getSubmitTimeStart() const {
+  return submitTimeStart_;
+}
+
+void ListServerlessJobsRequest::setSubmitTimeStart(const std::string &submitTimeStart) {
+  submitTimeStart_ = submitTimeStart;
+  setParameter(std::string("SubmitTimeStart"), submitTimeStart);
+}
+
+long ListServerlessJobsRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void ListServerlessJobsRequest::setPageNumber(long pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string ListServerlessJobsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ListServerlessJobsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+long ListServerlessJobsRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void ListServerlessJobsRequest::setPageSize(long pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string ListServerlessJobsRequest::getState() const {
+  return state_;
+}
+
+void ListServerlessJobsRequest::setState(const std::string &state) {
+  state_ = state;
+  setParameter(std::string("State"), state);
+}
+
+std::string ListServerlessJobsRequest::getSubmitOrder() const {
+  return submitOrder_;
+}
+
+void ListServerlessJobsRequest::setSubmitOrder(const std::string &submitOrder) {
+  submitOrder_ = submitOrder;
+  setParameter(std::string("SubmitOrder"), submitOrder);
+}
+
+std::string ListServerlessJobsRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void ListServerlessJobsRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::vector<ListServerlessJobsRequest::std::string> ListServerlessJobsRequest::getJobNames() const {
+  return jobNames_;
+}
+
+void ListServerlessJobsRequest::setJobNames(const std::vector<ListServerlessJobsRequest::std::string> &jobNames) {
+  jobNames_ = jobNames;
+  for(int dep1 = 0; dep1 != jobNames.size(); dep1++) {
+    setParameter(std::string("JobNames") + "." + std::to_string(dep1 + 1), jobNames[dep1]);
+  }
+}
+
+std::vector<ListServerlessJobsRequest::std::string> ListServerlessJobsRequest::getUsers() const {
+  return users_;
+}
+
+void ListServerlessJobsRequest::setUsers(const std::vector<ListServerlessJobsRequest::std::string> &users) {
+  users_ = users;
+  for(int dep1 = 0; dep1 != users.size(); dep1++) {
+    setParameter(std::string("Users") + "." + std::to_string(dep1 + 1), users[dep1]);
+  }
+}
+
+std::string ListServerlessJobsRequest::getStartOrder() const {
+  return startOrder_;
+}
+
+void ListServerlessJobsRequest::setStartOrder(const std::string &startOrder) {
+  startOrder_ = startOrder;
+  setParameter(std::string("StartOrder"), startOrder);
+}
+
+std::string ListServerlessJobsRequest::getSubmitTimeEnd() const {
+  return submitTimeEnd_;
+}
+
+void ListServerlessJobsRequest::setSubmitTimeEnd(const std::string &submitTimeEnd) {
+  submitTimeEnd_ = submitTimeEnd;
+  setParameter(std::string("SubmitTimeEnd"), submitTimeEnd);
+}
+
+std::vector<ListServerlessJobsRequest::std::string> ListServerlessJobsRequest::getQueues() const {
+  return queues_;
+}
+
+void ListServerlessJobsRequest::setQueues(const std::vector<ListServerlessJobsRequest::std::string> &queues) {
+  queues_ = queues;
+  for(int dep1 = 0; dep1 != queues.size(); dep1++) {
+    setParameter(std::string("Queues") + "." + std::to_string(dep1 + 1), queues[dep1]);
+  }
+}
+
+std::vector<ListServerlessJobsRequest::std::string> ListServerlessJobsRequest::getJobIds() const {
+  return jobIds_;
+}
+
+void ListServerlessJobsRequest::setJobIds(const std::vector<ListServerlessJobsRequest::std::string> &jobIds) {
+  jobIds_ = jobIds;
+  for(int dep1 = 0; dep1 != jobIds.size(); dep1++) {
+    setParameter(std::string("JobIds") + "." + std::to_string(dep1 + 1), jobIds[dep1]);
+  }
+}
+

ehpc/src/model/ListServerlessJobsResult.cc

@@ -0,0 +1,96 @@
+/*
+ * 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/ehpc/model/ListServerlessJobsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+ListServerlessJobsResult::ListServerlessJobsResult() :
+	ServiceResult()
+{}
+
+ListServerlessJobsResult::ListServerlessJobsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListServerlessJobsResult::~ListServerlessJobsResult()
+{}
+
+void ListServerlessJobsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allJobsNode = value["Jobs"]["JobInfo"];
+	for (auto valueJobsJobInfo : allJobsNode)
+	{
+		JobInfo jobsObject;
+		if(!valueJobsJobInfo["Id"].isNull())
+			jobsObject.id = valueJobsJobInfo["Id"].asString();
+		if(!valueJobsJobInfo["Name"].isNull())
+			jobsObject.name = valueJobsJobInfo["Name"].asString();
+		if(!valueJobsJobInfo["Owner"].isNull())
+			jobsObject.owner = valueJobsJobInfo["Owner"].asString();
+		if(!valueJobsJobInfo["IsArrayJob"].isNull())
+			jobsObject.isArrayJob = valueJobsJobInfo["IsArrayJob"].asString() == "true";
+		if(!valueJobsJobInfo["State"].isNull())
+			jobsObject.state = valueJobsJobInfo["State"].asString();
+		if(!valueJobsJobInfo["SubmitTime"].isNull())
+			jobsObject.submitTime = valueJobsJobInfo["SubmitTime"].asString();
+		if(!valueJobsJobInfo["StartTime"].isNull())
+			jobsObject.startTime = valueJobsJobInfo["StartTime"].asString();
+		if(!valueJobsJobInfo["EndTime"].isNull())
+			jobsObject.endTime = valueJobsJobInfo["EndTime"].asString();
+		if(!valueJobsJobInfo["Priority"].isNull())
+			jobsObject.priority = valueJobsJobInfo["Priority"].asString();
+		if(!valueJobsJobInfo["Queue"].isNull())
+			jobsObject.queue = valueJobsJobInfo["Queue"].asString();
+		jobs_.push_back(jobsObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stol(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stol(value["PageNumber"].asString());
+
+}
+
+int ListServerlessJobsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+long ListServerlessJobsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+std::vector<ListServerlessJobsResult::JobInfo> ListServerlessJobsResult::getJobs()const
+{
+	return jobs_;
+}
+
+long ListServerlessJobsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

ehpc/src/model/ModifyClusterAttributesRequest.cc

@@ -96,6 +96,19 @@ void ModifyClusterAttributesRequest::setPassword(const std::string &password) {
   setParameter(std::string("Password"), password);
 }
 
+ModifyClusterAttributesRequest::WinAdPar ModifyClusterAttributesRequest::getWinAdPar() const {
+  return winAdPar_;
+}
+
+void ModifyClusterAttributesRequest::setWinAdPar(const ModifyClusterAttributesRequest::WinAdPar &winAdPar) {
+  winAdPar_ = winAdPar;
+  setParameter(std::string("WinAdPar") + ".AdUser", winAdPar.adUser);
+  setParameter(std::string("WinAdPar") + ".AdUserPasswd", winAdPar.adUserPasswd);
+  setParameter(std::string("WinAdPar") + ".AdIp", winAdPar.adIp);
+  setParameter(std::string("WinAdPar") + ".FallbackHomeDir", winAdPar.fallbackHomeDir);
+  setParameter(std::string("WinAdPar") + ".AdDc", winAdPar.adDc);
+}
+
 std::string ModifyClusterAttributesRequest::getName() const {
   return name_;
 }

ehpc/src/model/SetAutoScaleConfigRequest.cc

@@ -34,6 +34,15 @@ void SetAutoScaleConfigRequest::setImageId(const std::string &imageId) {
   setParameter(std::string("ImageId"), imageId);
 }
 
+std::string SetAutoScaleConfigRequest::getDnsConfig() const {
+  return dnsConfig_;
+}
+
+void SetAutoScaleConfigRequest::setDnsConfig(const std::string &dnsConfig) {
+  dnsConfig_ = dnsConfig;
+  setParameter(std::string("DnsConfig"), dnsConfig);
+}
+
 float SetAutoScaleConfigRequest::getSpotPriceLimit() const {
   return spotPriceLimit_;
 }
@@ -133,6 +142,15 @@ void SetAutoScaleConfigRequest::setMaxNodesInCluster(int maxNodesInCluster) {
   setParameter(std::string("MaxNodesInCluster"), std::to_string(maxNodesInCluster));
 }
 
+bool SetAutoScaleConfigRequest::getComputeEnableHt() const {
+  return computeEnableHt_;
+}
+
+void SetAutoScaleConfigRequest::setComputeEnableHt(bool computeEnableHt) {
+  computeEnableHt_ = computeEnableHt;
+  setParameter(std::string("ComputeEnableHt"), computeEnableHt ? "true" : "false");
+}
+
 int SetAutoScaleConfigRequest::getShrinkIntervalInMinutes() const {
   return shrinkIntervalInMinutes_;
 }
@@ -153,6 +171,7 @@ void SetAutoScaleConfigRequest::setQueues(const std::vector<SetAutoScaleConfigRe
   std::string queuesObjStr = std::string("Queues") + "." + std::to_string(dep1 + 1);
     setParameter(queuesObjStr + ".QueueName", queuesObj.queueName);
     setParameter(queuesObjStr + ".SystemDiskLevel", queuesObj.systemDiskLevel);
+    setParameter(queuesObjStr + ".SortedByInventory", queuesObj.sortedByInventory ? "true" : "false");
     for(int dep2 = 0; dep2 != queuesObj.instanceTypes.size(); dep2++) {
     auto instanceTypesObj = queuesObj.instanceTypes.at(dep2);
     std::string instanceTypesObjStr = queuesObjStr + ".InstanceTypes" + "." + std::to_string(dep2 + 1);

ehpc/src/model/StopServerlessJobsRequest.cc

@@ -0,0 +1,56 @@
+/*
+ * 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/ehpc/model/StopServerlessJobsRequest.h>
+
+using AlibabaCloud::EHPC::Model::StopServerlessJobsRequest;
+
+StopServerlessJobsRequest::StopServerlessJobsRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "StopServerlessJobs") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+StopServerlessJobsRequest::~StopServerlessJobsRequest() {}
+
+std::string StopServerlessJobsRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void StopServerlessJobsRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string StopServerlessJobsRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void StopServerlessJobsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::vector<StopServerlessJobsRequest::std::string> StopServerlessJobsRequest::getJobIds() const {
+  return jobIds_;
+}
+
+void StopServerlessJobsRequest::setJobIds(const std::vector<StopServerlessJobsRequest::std::string> &jobIds) {
+  jobIds_ = jobIds;
+  for(int dep1 = 0; dep1 != jobIds.size(); dep1++) {
+    setParameter(std::string("JobIds") + "." + std::to_string(dep1 + 1), jobIds[dep1]);
+  }
+}
+

ehpc/src/model/StopServerlessJobsResult.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/ehpc/model/StopServerlessJobsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+StopServerlessJobsResult::StopServerlessJobsResult() :
+	ServiceResult()
+{}
+
+StopServerlessJobsResult::StopServerlessJobsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+StopServerlessJobsResult::~StopServerlessJobsResult()
+{}
+
+void StopServerlessJobsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

ehpc/src/model/SubmitServerlessJobRequest.cc

@@ -0,0 +1,271 @@
+/*
+ * 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/ehpc/model/SubmitServerlessJobRequest.h>
+
+using AlibabaCloud::EHPC::Model::SubmitServerlessJobRequest;
+
+SubmitServerlessJobRequest::SubmitServerlessJobRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "SubmitServerlessJob") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+SubmitServerlessJobRequest::~SubmitServerlessJobRequest() {}
+
+SubmitServerlessJobRequest::Container SubmitServerlessJobRequest::getContainer() const {
+  return container_;
+}
+
+void SubmitServerlessJobRequest::setContainer(const SubmitServerlessJobRequest::Container &container) {
+  container_ = container;
+  for(int dep1 = 0; dep1 != container.volumeMount.size(); dep1++) {
+    setParameter(std::string("Container") + ".VolumeMount." + std::to_string(dep1 + 1) + ".FlexVolume.Options", container.volumeMount[dep1].flexVolumeOptions);
+    setParameter(std::string("Container") + ".VolumeMount." + std::to_string(dep1 + 1) + ".NFSVolume.Server", container.volumeMount[dep1].nFSVolumeServer);
+    setParameter(std::string("Container") + ".VolumeMount." + std::to_string(dep1 + 1) + ".MountPath", container.volumeMount[dep1].mountPath);
+    setParameter(std::string("Container") + ".VolumeMount." + std::to_string(dep1 + 1) + ".ReadOnly", container.volumeMount[dep1].readOnly ? "true" : "false");
+    setParameter(std::string("Container") + ".VolumeMount." + std::to_string(dep1 + 1) + ".MountPropagation", container.volumeMount[dep1].mountPropagation);
+    setParameter(std::string("Container") + ".VolumeMount." + std::to_string(dep1 + 1) + ".SubPath", container.volumeMount[dep1].subPath);
+    setParameter(std::string("Container") + ".VolumeMount." + std::to_string(dep1 + 1) + ".NFSVolume.Path", container.volumeMount[dep1].nFSVolumePath);
+    setParameter(std::string("Container") + ".VolumeMount." + std::to_string(dep1 + 1) + ".Type", container.volumeMount[dep1].type);
+    setParameter(std::string("Container") + ".VolumeMount." + std::to_string(dep1 + 1) + ".NFSVolume.ReadOnly", container.volumeMount[dep1].nFSVolumeReadOnly ? "true" : "false");
+    setParameter(std::string("Container") + ".VolumeMount." + std::to_string(dep1 + 1) + ".FlexVolume.Driver", container.volumeMount[dep1].flexVolumeDriver);
+  }
+  setParameter(std::string("Container") + ".Image", container.image);
+  for(int dep1 = 0; dep1 != container.port.size(); dep1++) {
+    setParameter(std::string("Container") + ".Port." + std::to_string(dep1 + 1) + ".Protocol", container.port[dep1].protocol);
+    setParameter(std::string("Container") + ".Port." + std::to_string(dep1 + 1) + ".Port", std::to_string(container.port[dep1].port));
+  }
+  for(int dep1 = 0; dep1 != container.environmentVar.size(); dep1++) {
+    setParameter(std::string("Container") + ".EnvironmentVar." + std::to_string(dep1 + 1) + ".Name", container.environmentVar[dep1].name);
+    setParameter(std::string("Container") + ".EnvironmentVar." + std::to_string(dep1 + 1) + ".Value", container.environmentVar[dep1].value);
+  }
+  setParameter(std::string("Container") + ".WorkingDir", container.workingDir);
+  for(int dep1 = 0; dep1 != container.arg.size(); dep1++) {
+    setParameter(std::string("Container") + ".Arg." + std::to_string(dep1 + 1), container.arg[dep1]);
+  }
+  setParameter(std::string("Container") + ".Name", container.name);
+  setParameter(std::string("Container") + ".Gpu", std::to_string(container.gpu));
+  for(int dep1 = 0; dep1 != container.command.size(); dep1++) {
+    setParameter(std::string("Container") + ".Command." + std::to_string(dep1 + 1), container.command[dep1]);
+  }
+}
+
+float SubmitServerlessJobRequest::getMemory() const {
+  return memory_;
+}
+
+void SubmitServerlessJobRequest::setMemory(float memory) {
+  memory_ = memory;
+  setParameter(std::string("Memory"), std::to_string(memory));
+}
+
+std::vector<SubmitServerlessJobRequest::DependsOn> SubmitServerlessJobRequest::getDependsOn() const {
+  return dependsOn_;
+}
+
+void SubmitServerlessJobRequest::setDependsOn(const std::vector<SubmitServerlessJobRequest::DependsOn> &dependsOn) {
+  dependsOn_ = dependsOn;
+  for(int dep1 = 0; dep1 != dependsOn.size(); dep1++) {
+    setParameter(std::string("DependsOn") + "." + std::to_string(dep1 + 1) + ".JobId", dependsOn[dep1].jobId);
+    setParameter(std::string("DependsOn") + "." + std::to_string(dep1 + 1) + ".Type", dependsOn[dep1].type);
+  }
+}
+
+float SubmitServerlessJobRequest::getSpotPriceLimit() const {
+  return spotPriceLimit_;
+}
+
+void SubmitServerlessJobRequest::setSpotPriceLimit(float spotPriceLimit) {
+  spotPriceLimit_ = spotPriceLimit;
+  setParameter(std::string("SpotPriceLimit"), std::to_string(spotPriceLimit));
+}
+
+std::string SubmitServerlessJobRequest::getJobQueue() const {
+  return jobQueue_;
+}
+
+void SubmitServerlessJobRequest::setJobQueue(const std::string &jobQueue) {
+  jobQueue_ = jobQueue;
+  setParameter(std::string("JobQueue"), jobQueue);
+}
+
+long SubmitServerlessJobRequest::getTimeout() const {
+  return timeout_;
+}
+
+void SubmitServerlessJobRequest::setTimeout(long timeout) {
+  timeout_ = timeout;
+  setParameter(std::string("Timeout"), std::to_string(timeout));
+}
+
+std::string SubmitServerlessJobRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void SubmitServerlessJobRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string SubmitServerlessJobRequest::getJobUser() const {
+  return jobUser_;
+}
+
+void SubmitServerlessJobRequest::setJobUser(const std::string &jobUser) {
+  jobUser_ = jobUser;
+  setParameter(std::string("JobUser"), jobUser);
+}
+
+std::vector<SubmitServerlessJobRequest::std::string> SubmitServerlessJobRequest::getInstanceType() const {
+  return instanceType_;
+}
+
+void SubmitServerlessJobRequest::setInstanceType(const std::vector<SubmitServerlessJobRequest::std::string> &instanceType) {
+  instanceType_ = instanceType;
+  for(int dep1 = 0; dep1 != instanceType.size(); dep1++) {
+    setParameter(std::string("InstanceType") + "." + std::to_string(dep1 + 1), instanceType[dep1]);
+  }
+}
+
+std::string SubmitServerlessJobRequest::getJobName() const {
+  return jobName_;
+}
+
+void SubmitServerlessJobRequest::setJobName(const std::string &jobName) {
+  jobName_ = jobName;
+  setParameter(std::string("JobName"), jobName);
+}
+
+long SubmitServerlessJobRequest::getJobPriority() const {
+  return jobPriority_;
+}
+
+void SubmitServerlessJobRequest::setJobPriority(long jobPriority) {
+  jobPriority_ = jobPriority;
+  setParameter(std::string("JobPriority"), std::to_string(jobPriority));
+}
+
+float SubmitServerlessJobRequest::getCpu() const {
+  return cpu_;
+}
+
+void SubmitServerlessJobRequest::setCpu(float cpu) {
+  cpu_ = cpu;
+  setParameter(std::string("Cpu"), std::to_string(cpu));
+}
+
+std::string SubmitServerlessJobRequest::getRamRoleName() const {
+  return ramRoleName_;
+}
+
+void SubmitServerlessJobRequest::setRamRoleName(const std::string &ramRoleName) {
+  ramRoleName_ = ramRoleName;
+  setParameter(std::string("RamRoleName"), ramRoleName);
+}
+
+std::vector<SubmitServerlessJobRequest::AcrRegistryInfo> SubmitServerlessJobRequest::getAcrRegistryInfo() const {
+  return acrRegistryInfo_;
+}
+
+void SubmitServerlessJobRequest::setAcrRegistryInfo(const std::vector<SubmitServerlessJobRequest::AcrRegistryInfo> &acrRegistryInfo) {
+  acrRegistryInfo_ = acrRegistryInfo;
+  for(int dep1 = 0; dep1 != acrRegistryInfo.size(); dep1++) {
+    setParameter(std::string("AcrRegistryInfo") + "." + std::to_string(dep1 + 1) + ".InstanceName", acrRegistryInfo[dep1].instanceName);
+    setParameter(std::string("AcrRegistryInfo") + "." + std::to_string(dep1 + 1) + ".InstanceId", acrRegistryInfo[dep1].instanceId);
+    setParameter(std::string("AcrRegistryInfo") + "." + std::to_string(dep1 + 1) + ".RegionId", acrRegistryInfo[dep1].regionId);
+    for(int dep2 = 0; dep2 != acrRegistryInfo[dep1].domain.size(); dep2++) {
+      setParameter(std::string("AcrRegistryInfo") + "." + std::to_string(dep1 + 1) + ".Domain." + std::to_string(dep2 + 1), acrRegistryInfo[dep1].domain[dep2]);
+    }
+  }
+}
+
+std::string SubmitServerlessJobRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void SubmitServerlessJobRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string SubmitServerlessJobRequest::getSpotStrategy() const {
+  return spotStrategy_;
+}
+
+void SubmitServerlessJobRequest::setSpotStrategy(const std::string &spotStrategy) {
+  spotStrategy_ = spotStrategy;
+  setParameter(std::string("SpotStrategy"), spotStrategy);
+}
+
+std::vector<SubmitServerlessJobRequest::std::string> SubmitServerlessJobRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void SubmitServerlessJobRequest::setVSwitchId(const std::vector<SubmitServerlessJobRequest::std::string> &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  for(int dep1 = 0; dep1 != vSwitchId.size(); dep1++) {
+    setParameter(std::string("VSwitchId") + "." + std::to_string(dep1 + 1), vSwitchId[dep1]);
+  }
+}
+
+std::vector<SubmitServerlessJobRequest::Volume> SubmitServerlessJobRequest::getVolume() const {
+  return volume_;
+}
+
+void SubmitServerlessJobRequest::setVolume(const std::vector<SubmitServerlessJobRequest::Volume> &volume) {
+  volume_ = volume;
+  for(int dep1 = 0; dep1 != volume.size(); dep1++) {
+    setParameter(std::string("Volume") + "." + std::to_string(dep1 + 1) + ".FlexVolume.Options", volume[dep1].flexVolumeOptions);
+    setParameter(std::string("Volume") + "." + std::to_string(dep1 + 1) + ".NFSVolume.Server", volume[dep1].nFSVolumeServer);
+    setParameter(std::string("Volume") + "." + std::to_string(dep1 + 1) + ".NFSVolume.Path", volume[dep1].nFSVolumePath);
+    setParameter(std::string("Volume") + "." + std::to_string(dep1 + 1) + ".NFSVolume.ReadOnly", volume[dep1].nFSVolumeReadOnly ? "true" : "false");
+    setParameter(std::string("Volume") + "." + std::to_string(dep1 + 1) + ".FlexVolume.Driver", volume[dep1].flexVolumeDriver);
+  }
+}
+
+SubmitServerlessJobRequest::RetryStrategy SubmitServerlessJobRequest::getRetryStrategy() const {
+  return retryStrategy_;
+}
+
+void SubmitServerlessJobRequest::setRetryStrategy(const SubmitServerlessJobRequest::RetryStrategy &retryStrategy) {
+  retryStrategy_ = retryStrategy;
+  for(int dep1 = 0; dep1 != retryStrategy.evaluateOnExit.size(); dep1++) {
+    setParameter(std::string("RetryStrategy") + ".EvaluateOnExit." + std::to_string(dep1 + 1) + ".Action", retryStrategy.evaluateOnExit[dep1].action);
+    setParameter(std::string("RetryStrategy") + ".EvaluateOnExit." + std::to_string(dep1 + 1) + ".OnExitCode", retryStrategy.evaluateOnExit[dep1].onExitCode);
+  }
+  setParameter(std::string("RetryStrategy") + ".Attempts", std::to_string(retryStrategy.attempts));
+}
+
+int SubmitServerlessJobRequest::getEphemeralStorage() const {
+  return ephemeralStorage_;
+}
+
+void SubmitServerlessJobRequest::setEphemeralStorage(int ephemeralStorage) {
+  ephemeralStorage_ = ephemeralStorage;
+  setParameter(std::string("EphemeralStorage"), std::to_string(ephemeralStorage));
+}
+
+SubmitServerlessJobRequest::ArrayProperties SubmitServerlessJobRequest::getArrayProperties() const {
+  return arrayProperties_;
+}
+
+void SubmitServerlessJobRequest::setArrayProperties(const SubmitServerlessJobRequest::ArrayProperties &arrayProperties) {
+  arrayProperties_ = arrayProperties;
+  setParameter(std::string("ArrayProperties") + ".IndexStart", std::to_string(arrayProperties.indexStart));
+  setParameter(std::string("ArrayProperties") + ".IndexStep", std::to_string(arrayProperties.indexStep));
+  setParameter(std::string("ArrayProperties") + ".IndexEnd", std::to_string(arrayProperties.indexEnd));
+}
+

ehpc/src/model/SubmitServerlessJobResult.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/ehpc/model/SubmitServerlessJobResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+SubmitServerlessJobResult::SubmitServerlessJobResult() :
+	ServiceResult()
+{}
+
+SubmitServerlessJobResult::SubmitServerlessJobResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SubmitServerlessJobResult::~SubmitServerlessJobResult()
+{}
+
+void SubmitServerlessJobResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["JobId"].isNull())
+		jobId_ = value["JobId"].asString();
+
+}
+
+std::string SubmitServerlessJobResult::getJobId()const
+{
+	return jobId_;
+}
+

ehpc/src/model/UpdateClusterVolumesRequest.cc

@@ -36,6 +36,7 @@ void UpdateClusterVolumesRequest::setAdditionalVolumes(const std::vector<UpdateC
   std::string additionalVolumesObjStr = std::string("AdditionalVolumes") + "." + std::to_string(dep1 + 1);
     setParameter(additionalVolumesObjStr + ".VolumeType", additionalVolumesObj.volumeType);
     setParameter(additionalVolumesObjStr + ".VolumeProtocol", additionalVolumesObj.volumeProtocol);
+    setParameter(additionalVolumesObjStr + ".VolumeMountOption", additionalVolumesObj.volumeMountOption);
     setParameter(additionalVolumesObjStr + ".LocalDirectory", additionalVolumesObj.localDirectory);
     setParameter(additionalVolumesObjStr + ".RemoteDirectory", additionalVolumesObj.remoteDirectory);
     for(int dep2 = 0; dep2 != additionalVolumesObj.roles.size(); dep2++) {

ehpc/src/model/UpdateQueueConfigRequest.cc

@@ -25,6 +25,15 @@ UpdateQueueConfigRequest::UpdateQueueConfigRequest()
 
 UpdateQueueConfigRequest::~UpdateQueueConfigRequest() {}
 
+std::string UpdateQueueConfigRequest::getDeploymentSetId() const {
+  return deploymentSetId_;
+}
+
+void UpdateQueueConfigRequest::setDeploymentSetId(const std::string &deploymentSetId) {
+  deploymentSetId_ = deploymentSetId;
+  setParameter(std::string("DeploymentSetId"), deploymentSetId);
+}
+
 std::string UpdateQueueConfigRequest::getQueueName() const {
   return queueName_;
 }

mse/CMakeLists.txt

@@ -21,12 +21,16 @@ set(mse_public_header
 	include/alibabacloud/mse/MseExport.h )
 
 set(mse_public_header_model 
+	include/alibabacloud/mse/model/AddAuthPolicyRequest.h
+	include/alibabacloud/mse/model/AddAuthPolicyResult.h
 	include/alibabacloud/mse/model/AddAuthResourceRequest.h
 	include/alibabacloud/mse/model/AddAuthResourceResult.h
 	include/alibabacloud/mse/model/AddBlackWhiteListRequest.h
 	include/alibabacloud/mse/model/AddBlackWhiteListResult.h
 	include/alibabacloud/mse/model/AddGatewayRequest.h
 	include/alibabacloud/mse/model/AddGatewayResult.h
+	include/alibabacloud/mse/model/AddGatewayAuthConsumerRequest.h
+	include/alibabacloud/mse/model/AddGatewayAuthConsumerResult.h
 	include/alibabacloud/mse/model/AddGatewayDomainRequest.h
 	include/alibabacloud/mse/model/AddGatewayDomainResult.h
 	include/alibabacloud/mse/model/AddGatewayRouteRequest.h
@@ -53,10 +57,14 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/CloneNacosConfigResult.h
 	include/alibabacloud/mse/model/CreateApplicationRequest.h
 	include/alibabacloud/mse/model/CreateApplicationResult.h
+	include/alibabacloud/mse/model/CreateCircuitBreakerRuleRequest.h
+	include/alibabacloud/mse/model/CreateCircuitBreakerRuleResult.h
 	include/alibabacloud/mse/model/CreateClusterRequest.h
 	include/alibabacloud/mse/model/CreateClusterResult.h
 	include/alibabacloud/mse/model/CreateEngineNamespaceRequest.h
 	include/alibabacloud/mse/model/CreateEngineNamespaceResult.h
+	include/alibabacloud/mse/model/CreateFlowRuleRequest.h
+	include/alibabacloud/mse/model/CreateFlowRuleResult.h
 	include/alibabacloud/mse/model/CreateMseServiceApplicationRequest.h
 	include/alibabacloud/mse/model/CreateMseServiceApplicationResult.h
 	include/alibabacloud/mse/model/CreateNacosConfigRequest.h
@@ -73,12 +81,20 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/CreateZnodeResult.h
 	include/alibabacloud/mse/model/DeleteAuthResourceRequest.h
 	include/alibabacloud/mse/model/DeleteAuthResourceResult.h
+	include/alibabacloud/mse/model/DeleteCircuitBreakerRulesRequest.h
+	include/alibabacloud/mse/model/DeleteCircuitBreakerRulesResult.h
 	include/alibabacloud/mse/model/DeleteClusterRequest.h
 	include/alibabacloud/mse/model/DeleteClusterResult.h
 	include/alibabacloud/mse/model/DeleteEngineNamespaceRequest.h
 	include/alibabacloud/mse/model/DeleteEngineNamespaceResult.h
+	include/alibabacloud/mse/model/DeleteFlowRulesRequest.h
+	include/alibabacloud/mse/model/DeleteFlowRulesResult.h
 	include/alibabacloud/mse/model/DeleteGatewayRequest.h
 	include/alibabacloud/mse/model/DeleteGatewayResult.h
+	include/alibabacloud/mse/model/DeleteGatewayAuthConsumerRequest.h
+	include/alibabacloud/mse/model/DeleteGatewayAuthConsumerResult.h
+	include/alibabacloud/mse/model/DeleteGatewayAuthConsumerResourceRequest.h
+	include/alibabacloud/mse/model/DeleteGatewayAuthConsumerResourceResult.h
 	include/alibabacloud/mse/model/DeleteGatewayDomainRequest.h
 	include/alibabacloud/mse/model/DeleteGatewayDomainResult.h
 	include/alibabacloud/mse/model/DeleteGatewayRouteRequest.h
@@ -99,6 +115,8 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/DeleteNacosInstanceResult.h
 	include/alibabacloud/mse/model/DeleteNacosServiceRequest.h
 	include/alibabacloud/mse/model/DeleteNacosServiceResult.h
+	include/alibabacloud/mse/model/DeleteNamespaceRequest.h
+	include/alibabacloud/mse/model/DeleteNamespaceResult.h
 	include/alibabacloud/mse/model/DeleteSecurityGroupRuleRequest.h
 	include/alibabacloud/mse/model/DeleteSecurityGroupRuleResult.h
 	include/alibabacloud/mse/model/DeleteServiceSourceRequest.h
@@ -111,6 +129,10 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/DeleteZnodeResult.h
 	include/alibabacloud/mse/model/ExportNacosConfigRequest.h
 	include/alibabacloud/mse/model/ExportNacosConfigResult.h
+	include/alibabacloud/mse/model/ExportZookeeperDataRequest.h
+	include/alibabacloud/mse/model/ExportZookeeperDataResult.h
+	include/alibabacloud/mse/model/FetchLosslessRuleListRequest.h
+	include/alibabacloud/mse/model/FetchLosslessRuleListResult.h
 	include/alibabacloud/mse/model/GetAppMessageQueueRouteRequest.h
 	include/alibabacloud/mse/model/GetAppMessageQueueRouteResult.h
 	include/alibabacloud/mse/model/GetApplicationListRequest.h
@@ -123,6 +145,8 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/GetEngineNamepaceResult.h
 	include/alibabacloud/mse/model/GetGatewayRequest.h
 	include/alibabacloud/mse/model/GetGatewayResult.h
+	include/alibabacloud/mse/model/GetGatewayAuthConsumerDetailRequest.h
+	include/alibabacloud/mse/model/GetGatewayAuthConsumerDetailResult.h
 	include/alibabacloud/mse/model/GetGatewayDomainDetailRequest.h
 	include/alibabacloud/mse/model/GetGatewayDomainDetailResult.h
 	include/alibabacloud/mse/model/GetGatewayOptionRequest.h
@@ -139,6 +163,8 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/GetImportFileUrlResult.h
 	include/alibabacloud/mse/model/GetKubernetesSourceRequest.h
 	include/alibabacloud/mse/model/GetKubernetesSourceResult.h
+	include/alibabacloud/mse/model/GetLosslessRuleByAppRequest.h
+	include/alibabacloud/mse/model/GetLosslessRuleByAppResult.h
 	include/alibabacloud/mse/model/GetMseFeatureSwitchRequest.h
 	include/alibabacloud/mse/model/GetMseFeatureSwitchResult.h
 	include/alibabacloud/mse/model/GetMseSourceRequest.h
@@ -155,8 +181,12 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/GetPluginsResult.h
 	include/alibabacloud/mse/model/GetServiceListRequest.h
 	include/alibabacloud/mse/model/GetServiceListResult.h
+	include/alibabacloud/mse/model/GetServiceListPageRequest.h
+	include/alibabacloud/mse/model/GetServiceListPageResult.h
 	include/alibabacloud/mse/model/GetServiceListenersRequest.h
 	include/alibabacloud/mse/model/GetServiceListenersResult.h
+	include/alibabacloud/mse/model/GetServiceMethodPageRequest.h
+	include/alibabacloud/mse/model/GetServiceMethodPageResult.h
 	include/alibabacloud/mse/model/GetTagsBySwimmingLaneGroupIdRequest.h
 	include/alibabacloud/mse/model/GetTagsBySwimmingLaneGroupIdResult.h
 	include/alibabacloud/mse/model/GetZookeeperDataImportUrlRequest.h
@@ -177,6 +207,10 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/ListAppBySwimmingLaneGroupTagResult.h
 	include/alibabacloud/mse/model/ListApplicationsWithTagRulesRequest.h
 	include/alibabacloud/mse/model/ListApplicationsWithTagRulesResult.h
+	include/alibabacloud/mse/model/ListAuthPolicyRequest.h
+	include/alibabacloud/mse/model/ListAuthPolicyResult.h
+	include/alibabacloud/mse/model/ListCircuitBreakerRulesRequest.h
+	include/alibabacloud/mse/model/ListCircuitBreakerRulesResult.h
 	include/alibabacloud/mse/model/ListClusterConnectionTypesRequest.h
 	include/alibabacloud/mse/model/ListClusterConnectionTypesResult.h
 	include/alibabacloud/mse/model/ListClusterHealthCheckTaskRequest.h
@@ -195,12 +229,22 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/ListEurekaInstancesResult.h
 	include/alibabacloud/mse/model/ListEurekaServicesRequest.h
 	include/alibabacloud/mse/model/ListEurekaServicesResult.h
+	include/alibabacloud/mse/model/ListExportZookeeperDataRequest.h
+	include/alibabacloud/mse/model/ListExportZookeeperDataResult.h
+	include/alibabacloud/mse/model/ListFlowRulesRequest.h
+	include/alibabacloud/mse/model/ListFlowRulesResult.h
 	include/alibabacloud/mse/model/ListGatewayRequest.h
 	include/alibabacloud/mse/model/ListGatewayResult.h
+	include/alibabacloud/mse/model/ListGatewayAuthConsumerRequest.h
+	include/alibabacloud/mse/model/ListGatewayAuthConsumerResult.h
+	include/alibabacloud/mse/model/ListGatewayAuthConsumerResourceRequest.h
+	include/alibabacloud/mse/model/ListGatewayAuthConsumerResourceResult.h
 	include/alibabacloud/mse/model/ListGatewayDomainRequest.h
 	include/alibabacloud/mse/model/ListGatewayDomainResult.h
 	include/alibabacloud/mse/model/ListGatewayRouteRequest.h
 	include/alibabacloud/mse/model/ListGatewayRouteResult.h
+	include/alibabacloud/mse/model/ListGatewayRouteOnAuthRequest.h
+	include/alibabacloud/mse/model/ListGatewayRouteOnAuthResult.h
 	include/alibabacloud/mse/model/ListGatewayServiceRequest.h
 	include/alibabacloud/mse/model/ListGatewayServiceResult.h
 	include/alibabacloud/mse/model/ListGatewaySlbRequest.h
@@ -271,12 +315,18 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/QueryInstancesInfoResult.h
 	include/alibabacloud/mse/model/QueryMonitorRequest.h
 	include/alibabacloud/mse/model/QueryMonitorResult.h
+	include/alibabacloud/mse/model/QueryNamespaceRequest.h
+	include/alibabacloud/mse/model/QueryNamespaceResult.h
 	include/alibabacloud/mse/model/QuerySlbSpecRequest.h
 	include/alibabacloud/mse/model/QuerySlbSpecResult.h
 	include/alibabacloud/mse/model/QuerySwimmingLaneByIdRequest.h
 	include/alibabacloud/mse/model/QuerySwimmingLaneByIdResult.h
 	include/alibabacloud/mse/model/QueryZnodeDetailRequest.h
 	include/alibabacloud/mse/model/QueryZnodeDetailResult.h
+	include/alibabacloud/mse/model/RemoveApplicationRequest.h
+	include/alibabacloud/mse/model/RemoveApplicationResult.h
+	include/alibabacloud/mse/model/RemoveAuthPolicyRequest.h
+	include/alibabacloud/mse/model/RemoveAuthPolicyResult.h
 	include/alibabacloud/mse/model/RestartClusterRequest.h
 	include/alibabacloud/mse/model/RestartClusterResult.h
 	include/alibabacloud/mse/model/RetryClusterRequest.h
@@ -289,8 +339,12 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/UntagResourcesResult.h
 	include/alibabacloud/mse/model/UpdateAclRequest.h
 	include/alibabacloud/mse/model/UpdateAclResult.h
+	include/alibabacloud/mse/model/UpdateAuthPolicyRequest.h
+	include/alibabacloud/mse/model/UpdateAuthPolicyResult.h
 	include/alibabacloud/mse/model/UpdateBlackWhiteListRequest.h
 	include/alibabacloud/mse/model/UpdateBlackWhiteListResult.h
+	include/alibabacloud/mse/model/UpdateCircuitBreakerRuleRequest.h
+	include/alibabacloud/mse/model/UpdateCircuitBreakerRuleResult.h
 	include/alibabacloud/mse/model/UpdateClusterRequest.h
 	include/alibabacloud/mse/model/UpdateClusterResult.h
 	include/alibabacloud/mse/model/UpdateClusterSpecRequest.h
@@ -299,6 +353,16 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/UpdateConfigResult.h
 	include/alibabacloud/mse/model/UpdateEngineNamespaceRequest.h
 	include/alibabacloud/mse/model/UpdateEngineNamespaceResult.h
+	include/alibabacloud/mse/model/UpdateFlowRuleRequest.h
+	include/alibabacloud/mse/model/UpdateFlowRuleResult.h
+	include/alibabacloud/mse/model/UpdateGatewayAuthConsumerRequest.h
+	include/alibabacloud/mse/model/UpdateGatewayAuthConsumerResult.h
+	include/alibabacloud/mse/model/UpdateGatewayAuthConsumerResourceRequest.h
+	include/alibabacloud/mse/model/UpdateGatewayAuthConsumerResourceResult.h
+	include/alibabacloud/mse/model/UpdateGatewayAuthConsumerResourceStatusRequest.h
+	include/alibabacloud/mse/model/UpdateGatewayAuthConsumerResourceStatusResult.h
+	include/alibabacloud/mse/model/UpdateGatewayAuthConsumerStatusRequest.h
+	include/alibabacloud/mse/model/UpdateGatewayAuthConsumerStatusResult.h
 	include/alibabacloud/mse/model/UpdateGatewayDomainRequest.h
 	include/alibabacloud/mse/model/UpdateGatewayDomainResult.h
 	include/alibabacloud/mse/model/UpdateGatewayNameRequest.h
@@ -307,6 +371,8 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/UpdateGatewayOptionResult.h
 	include/alibabacloud/mse/model/UpdateGatewayRouteRequest.h
 	include/alibabacloud/mse/model/UpdateGatewayRouteResult.h
+	include/alibabacloud/mse/model/UpdateGatewayRouteAuthRequest.h
+	include/alibabacloud/mse/model/UpdateGatewayRouteAuthResult.h
 	include/alibabacloud/mse/model/UpdateGatewayRouteCORSRequest.h
 	include/alibabacloud/mse/model/UpdateGatewayRouteCORSResult.h
 	include/alibabacloud/mse/model/UpdateGatewayRouteHTTPRewriteRequest.h
@@ -352,12 +418,16 @@ set(mse_public_header_model
 
 set(mse_src 
 	src/MseClient.cc
+	src/model/AddAuthPolicyRequest.cc
+	src/model/AddAuthPolicyResult.cc
 	src/model/AddAuthResourceRequest.cc
 	src/model/AddAuthResourceResult.cc
 	src/model/AddBlackWhiteListRequest.cc
 	src/model/AddBlackWhiteListResult.cc
 	src/model/AddGatewayRequest.cc
 	src/model/AddGatewayResult.cc
+	src/model/AddGatewayAuthConsumerRequest.cc
+	src/model/AddGatewayAuthConsumerResult.cc
 	src/model/AddGatewayDomainRequest.cc
 	src/model/AddGatewayDomainResult.cc
 	src/model/AddGatewayRouteRequest.cc
@@ -384,10 +454,14 @@ set(mse_src
 	src/model/CloneNacosConfigResult.cc
 	src/model/CreateApplicationRequest.cc
 	src/model/CreateApplicationResult.cc
+	src/model/CreateCircuitBreakerRuleRequest.cc
+	src/model/CreateCircuitBreakerRuleResult.cc
 	src/model/CreateClusterRequest.cc
 	src/model/CreateClusterResult.cc
 	src/model/CreateEngineNamespaceRequest.cc
 	src/model/CreateEngineNamespaceResult.cc
+	src/model/CreateFlowRuleRequest.cc
+	src/model/CreateFlowRuleResult.cc
 	src/model/CreateMseServiceApplicationRequest.cc
 	src/model/CreateMseServiceApplicationResult.cc
 	src/model/CreateNacosConfigRequest.cc
@@ -404,12 +478,20 @@ set(mse_src
 	src/model/CreateZnodeResult.cc
 	src/model/DeleteAuthResourceRequest.cc
 	src/model/DeleteAuthResourceResult.cc
+	src/model/DeleteCircuitBreakerRulesRequest.cc
+	src/model/DeleteCircuitBreakerRulesResult.cc
 	src/model/DeleteClusterRequest.cc
 	src/model/DeleteClusterResult.cc
 	src/model/DeleteEngineNamespaceRequest.cc
 	src/model/DeleteEngineNamespaceResult.cc
+	src/model/DeleteFlowRulesRequest.cc
+	src/model/DeleteFlowRulesResult.cc
 	src/model/DeleteGatewayRequest.cc
 	src/model/DeleteGatewayResult.cc
+	src/model/DeleteGatewayAuthConsumerRequest.cc
+	src/model/DeleteGatewayAuthConsumerResult.cc
+	src/model/DeleteGatewayAuthConsumerResourceRequest.cc
+	src/model/DeleteGatewayAuthConsumerResourceResult.cc
 	src/model/DeleteGatewayDomainRequest.cc
 	src/model/DeleteGatewayDomainResult.cc
 	src/model/DeleteGatewayRouteRequest.cc
@@ -430,6 +512,8 @@ set(mse_src
 	src/model/DeleteNacosInstanceResult.cc
 	src/model/DeleteNacosServiceRequest.cc
 	src/model/DeleteNacosServiceResult.cc
+	src/model/DeleteNamespaceRequest.cc
+	src/model/DeleteNamespaceResult.cc
 	src/model/DeleteSecurityGroupRuleRequest.cc
 	src/model/DeleteSecurityGroupRuleResult.cc
 	src/model/DeleteServiceSourceRequest.cc
@@ -442,6 +526,10 @@ set(mse_src
 	src/model/DeleteZnodeResult.cc
 	src/model/ExportNacosConfigRequest.cc
 	src/model/ExportNacosConfigResult.cc
+	src/model/ExportZookeeperDataRequest.cc
+	src/model/ExportZookeeperDataResult.cc
+	src/model/FetchLosslessRuleListRequest.cc
+	src/model/FetchLosslessRuleListResult.cc
 	src/model/GetAppMessageQueueRouteRequest.cc
 	src/model/GetAppMessageQueueRouteResult.cc
 	src/model/GetApplicationListRequest.cc
@@ -454,6 +542,8 @@ set(mse_src
 	src/model/GetEngineNamepaceResult.cc
 	src/model/GetGatewayRequest.cc
 	src/model/GetGatewayResult.cc
+	src/model/GetGatewayAuthConsumerDetailRequest.cc
+	src/model/GetGatewayAuthConsumerDetailResult.cc
 	src/model/GetGatewayDomainDetailRequest.cc
 	src/model/GetGatewayDomainDetailResult.cc
 	src/model/GetGatewayOptionRequest.cc
@@ -470,6 +560,8 @@ set(mse_src
 	src/model/GetImportFileUrlResult.cc
 	src/model/GetKubernetesSourceRequest.cc
 	src/model/GetKubernetesSourceResult.cc
+	src/model/GetLosslessRuleByAppRequest.cc
+	src/model/GetLosslessRuleByAppResult.cc
 	src/model/GetMseFeatureSwitchRequest.cc
 	src/model/GetMseFeatureSwitchResult.cc
 	src/model/GetMseSourceRequest.cc
@@ -486,8 +578,12 @@ set(mse_src
 	src/model/GetPluginsResult.cc
 	src/model/GetServiceListRequest.cc
 	src/model/GetServiceListResult.cc
+	src/model/GetServiceListPageRequest.cc
+	src/model/GetServiceListPageResult.cc
 	src/model/GetServiceListenersRequest.cc
 	src/model/GetServiceListenersResult.cc
+	src/model/GetServiceMethodPageRequest.cc
+	src/model/GetServiceMethodPageResult.cc
 	src/model/GetTagsBySwimmingLaneGroupIdRequest.cc
 	src/model/GetTagsBySwimmingLaneGroupIdResult.cc
 	src/model/GetZookeeperDataImportUrlRequest.cc
@@ -508,6 +604,10 @@ set(mse_src
 	src/model/ListAppBySwimmingLaneGroupTagResult.cc
 	src/model/ListApplicationsWithTagRulesRequest.cc
 	src/model/ListApplicationsWithTagRulesResult.cc
+	src/model/ListAuthPolicyRequest.cc
+	src/model/ListAuthPolicyResult.cc
+	src/model/ListCircuitBreakerRulesRequest.cc
+	src/model/ListCircuitBreakerRulesResult.cc
 	src/model/ListClusterConnectionTypesRequest.cc
 	src/model/ListClusterConnectionTypesResult.cc
 	src/model/ListClusterHealthCheckTaskRequest.cc
@@ -526,12 +626,22 @@ set(mse_src
 	src/model/ListEurekaInstancesResult.cc
 	src/model/ListEurekaServicesRequest.cc
 	src/model/ListEurekaServicesResult.cc
+	src/model/ListExportZookeeperDataRequest.cc
+	src/model/ListExportZookeeperDataResult.cc
+	src/model/ListFlowRulesRequest.cc
+	src/model/ListFlowRulesResult.cc
 	src/model/ListGatewayRequest.cc
 	src/model/ListGatewayResult.cc
+	src/model/ListGatewayAuthConsumerRequest.cc
+	src/model/ListGatewayAuthConsumerResult.cc
+	src/model/ListGatewayAuthConsumerResourceRequest.cc
+	src/model/ListGatewayAuthConsumerResourceResult.cc
 	src/model/ListGatewayDomainRequest.cc
 	src/model/ListGatewayDomainResult.cc
 	src/model/ListGatewayRouteRequest.cc
 	src/model/ListGatewayRouteResult.cc
+	src/model/ListGatewayRouteOnAuthRequest.cc
+	src/model/ListGatewayRouteOnAuthResult.cc
 	src/model/ListGatewayServiceRequest.cc
 	src/model/ListGatewayServiceResult.cc
 	src/model/ListGatewaySlbRequest.cc
@@ -602,12 +712,18 @@ set(mse_src
 	src/model/QueryInstancesInfoResult.cc
 	src/model/QueryMonitorRequest.cc
 	src/model/QueryMonitorResult.cc
+	src/model/QueryNamespaceRequest.cc
+	src/model/QueryNamespaceResult.cc
 	src/model/QuerySlbSpecRequest.cc
 	src/model/QuerySlbSpecResult.cc
 	src/model/QuerySwimmingLaneByIdRequest.cc
 	src/model/QuerySwimmingLaneByIdResult.cc
 	src/model/QueryZnodeDetailRequest.cc
 	src/model/QueryZnodeDetailResult.cc
+	src/model/RemoveApplicationRequest.cc
+	src/model/RemoveApplicationResult.cc
+	src/model/RemoveAuthPolicyRequest.cc
+	src/model/RemoveAuthPolicyResult.cc
 	src/model/RestartClusterRequest.cc
 	src/model/RestartClusterResult.cc
 	src/model/RetryClusterRequest.cc
@@ -620,8 +736,12 @@ set(mse_src
 	src/model/UntagResourcesResult.cc
 	src/model/UpdateAclRequest.cc
 	src/model/UpdateAclResult.cc
+	src/model/UpdateAuthPolicyRequest.cc
+	src/model/UpdateAuthPolicyResult.cc
 	src/model/UpdateBlackWhiteListRequest.cc
 	src/model/UpdateBlackWhiteListResult.cc
+	src/model/UpdateCircuitBreakerRuleRequest.cc
+	src/model/UpdateCircuitBreakerRuleResult.cc
 	src/model/UpdateClusterRequest.cc
 	src/model/UpdateClusterResult.cc
 	src/model/UpdateClusterSpecRequest.cc
@@ -630,6 +750,16 @@ set(mse_src
 	src/model/UpdateConfigResult.cc
 	src/model/UpdateEngineNamespaceRequest.cc
 	src/model/UpdateEngineNamespaceResult.cc
+	src/model/UpdateFlowRuleRequest.cc
+	src/model/UpdateFlowRuleResult.cc
+	src/model/UpdateGatewayAuthConsumerRequest.cc
+	src/model/UpdateGatewayAuthConsumerResult.cc
+	src/model/UpdateGatewayAuthConsumerResourceRequest.cc
+	src/model/UpdateGatewayAuthConsumerResourceResult.cc
+	src/model/UpdateGatewayAuthConsumerResourceStatusRequest.cc
+	src/model/UpdateGatewayAuthConsumerResourceStatusResult.cc
+	src/model/UpdateGatewayAuthConsumerStatusRequest.cc
+	src/model/UpdateGatewayAuthConsumerStatusResult.cc
 	src/model/UpdateGatewayDomainRequest.cc
 	src/model/UpdateGatewayDomainResult.cc
 	src/model/UpdateGatewayNameRequest.cc
@@ -638,6 +768,8 @@ set(mse_src
 	src/model/UpdateGatewayOptionResult.cc
 	src/model/UpdateGatewayRouteRequest.cc
 	src/model/UpdateGatewayRouteResult.cc
+	src/model/UpdateGatewayRouteAuthRequest.cc
+	src/model/UpdateGatewayRouteAuthResult.cc
 	src/model/UpdateGatewayRouteCORSRequest.cc
 	src/model/UpdateGatewayRouteCORSResult.cc
 	src/model/UpdateGatewayRouteHTTPRewriteRequest.cc

mse/include/alibabacloud/mse/MseClient.h

@@ -22,12 +22,16 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "MseExport.h"
+#include "model/AddAuthPolicyRequest.h"
+#include "model/AddAuthPolicyResult.h"
 #include "model/AddAuthResourceRequest.h"
 #include "model/AddAuthResourceResult.h"
 #include "model/AddBlackWhiteListRequest.h"
 #include "model/AddBlackWhiteListResult.h"
 #include "model/AddGatewayRequest.h"
 #include "model/AddGatewayResult.h"
+#include "model/AddGatewayAuthConsumerRequest.h"
+#include "model/AddGatewayAuthConsumerResult.h"
 #include "model/AddGatewayDomainRequest.h"
 #include "model/AddGatewayDomainResult.h"
 #include "model/AddGatewayRouteRequest.h"
@@ -54,10 +58,14 @@
 #include "model/CloneNacosConfigResult.h"
 #include "model/CreateApplicationRequest.h"
 #include "model/CreateApplicationResult.h"
+#include "model/CreateCircuitBreakerRuleRequest.h"
+#include "model/CreateCircuitBreakerRuleResult.h"
 #include "model/CreateClusterRequest.h"
 #include "model/CreateClusterResult.h"
 #include "model/CreateEngineNamespaceRequest.h"
 #include "model/CreateEngineNamespaceResult.h"
+#include "model/CreateFlowRuleRequest.h"
+#include "model/CreateFlowRuleResult.h"
 #include "model/CreateMseServiceApplicationRequest.h"
 #include "model/CreateMseServiceApplicationResult.h"
 #include "model/CreateNacosConfigRequest.h"
@@ -74,12 +82,20 @@
 #include "model/CreateZnodeResult.h"
 #include "model/DeleteAuthResourceRequest.h"
 #include "model/DeleteAuthResourceResult.h"
+#include "model/DeleteCircuitBreakerRulesRequest.h"
+#include "model/DeleteCircuitBreakerRulesResult.h"
 #include "model/DeleteClusterRequest.h"
 #include "model/DeleteClusterResult.h"
 #include "model/DeleteEngineNamespaceRequest.h"
 #include "model/DeleteEngineNamespaceResult.h"
+#include "model/DeleteFlowRulesRequest.h"
+#include "model/DeleteFlowRulesResult.h"
 #include "model/DeleteGatewayRequest.h"
 #include "model/DeleteGatewayResult.h"
+#include "model/DeleteGatewayAuthConsumerRequest.h"
+#include "model/DeleteGatewayAuthConsumerResult.h"
+#include "model/DeleteGatewayAuthConsumerResourceRequest.h"
+#include "model/DeleteGatewayAuthConsumerResourceResult.h"
 #include "model/DeleteGatewayDomainRequest.h"
 #include "model/DeleteGatewayDomainResult.h"
 #include "model/DeleteGatewayRouteRequest.h"
@@ -100,6 +116,8 @@
 #include "model/DeleteNacosInstanceResult.h"
 #include "model/DeleteNacosServiceRequest.h"
 #include "model/DeleteNacosServiceResult.h"
+#include "model/DeleteNamespaceRequest.h"
+#include "model/DeleteNamespaceResult.h"
 #include "model/DeleteSecurityGroupRuleRequest.h"
 #include "model/DeleteSecurityGroupRuleResult.h"
 #include "model/DeleteServiceSourceRequest.h"
@@ -112,6 +130,10 @@
 #include "model/DeleteZnodeResult.h"
 #include "model/ExportNacosConfigRequest.h"
 #include "model/ExportNacosConfigResult.h"
+#include "model/ExportZookeeperDataRequest.h"
+#include "model/ExportZookeeperDataResult.h"
+#include "model/FetchLosslessRuleListRequest.h"
+#include "model/FetchLosslessRuleListResult.h"
 #include "model/GetAppMessageQueueRouteRequest.h"
 #include "model/GetAppMessageQueueRouteResult.h"
 #include "model/GetApplicationListRequest.h"
@@ -124,6 +146,8 @@
 #include "model/GetEngineNamepaceResult.h"
 #include "model/GetGatewayRequest.h"
 #include "model/GetGatewayResult.h"
+#include "model/GetGatewayAuthConsumerDetailRequest.h"
+#include "model/GetGatewayAuthConsumerDetailResult.h"
 #include "model/GetGatewayDomainDetailRequest.h"
 #include "model/GetGatewayDomainDetailResult.h"
 #include "model/GetGatewayOptionRequest.h"
@@ -140,6 +164,8 @@
 #include "model/GetImportFileUrlResult.h"
 #include "model/GetKubernetesSourceRequest.h"
 #include "model/GetKubernetesSourceResult.h"
+#include "model/GetLosslessRuleByAppRequest.h"
+#include "model/GetLosslessRuleByAppResult.h"
 #include "model/GetMseFeatureSwitchRequest.h"
 #include "model/GetMseFeatureSwitchResult.h"
 #include "model/GetMseSourceRequest.h"
@@ -156,8 +182,12 @@
 #include "model/GetPluginsResult.h"
 #include "model/GetServiceListRequest.h"
 #include "model/GetServiceListResult.h"
+#include "model/GetServiceListPageRequest.h"
+#include "model/GetServiceListPageResult.h"
 #include "model/GetServiceListenersRequest.h"
 #include "model/GetServiceListenersResult.h"
+#include "model/GetServiceMethodPageRequest.h"
+#include "model/GetServiceMethodPageResult.h"
 #include "model/GetTagsBySwimmingLaneGroupIdRequest.h"
 #include "model/GetTagsBySwimmingLaneGroupIdResult.h"
 #include "model/GetZookeeperDataImportUrlRequest.h"
@@ -178,6 +208,10 @@
 #include "model/ListAppBySwimmingLaneGroupTagResult.h"
 #include "model/ListApplicationsWithTagRulesRequest.h"
 #include "model/ListApplicationsWithTagRulesResult.h"
+#include "model/ListAuthPolicyRequest.h"
+#include "model/ListAuthPolicyResult.h"
+#include "model/ListCircuitBreakerRulesRequest.h"
+#include "model/ListCircuitBreakerRulesResult.h"
 #include "model/ListClusterConnectionTypesRequest.h"
 #include "model/ListClusterConnectionTypesResult.h"
 #include "model/ListClusterHealthCheckTaskRequest.h"
@@ -196,12 +230,22 @@
 #include "model/ListEurekaInstancesResult.h"
 #include "model/ListEurekaServicesRequest.h"
 #include "model/ListEurekaServicesResult.h"
+#include "model/ListExportZookeeperDataRequest.h"
+#include "model/ListExportZookeeperDataResult.h"
+#include "model/ListFlowRulesRequest.h"
+#include "model/ListFlowRulesResult.h"
 #include "model/ListGatewayRequest.h"
 #include "model/ListGatewayResult.h"
+#include "model/ListGatewayAuthConsumerRequest.h"
+#include "model/ListGatewayAuthConsumerResult.h"
+#include "model/ListGatewayAuthConsumerResourceRequest.h"
+#include "model/ListGatewayAuthConsumerResourceResult.h"
 #include "model/ListGatewayDomainRequest.h"
 #include "model/ListGatewayDomainResult.h"
 #include "model/ListGatewayRouteRequest.h"
 #include "model/ListGatewayRouteResult.h"
+#include "model/ListGatewayRouteOnAuthRequest.h"
+#include "model/ListGatewayRouteOnAuthResult.h"
 #include "model/ListGatewayServiceRequest.h"
 #include "model/ListGatewayServiceResult.h"
 #include "model/ListGatewaySlbRequest.h"
@@ -272,12 +316,18 @@
 #include "model/QueryInstancesInfoResult.h"
 #include "model/QueryMonitorRequest.h"
 #include "model/QueryMonitorResult.h"
+#include "model/QueryNamespaceRequest.h"
+#include "model/QueryNamespaceResult.h"
 #include "model/QuerySlbSpecRequest.h"
 #include "model/QuerySlbSpecResult.h"
 #include "model/QuerySwimmingLaneByIdRequest.h"
 #include "model/QuerySwimmingLaneByIdResult.h"
 #include "model/QueryZnodeDetailRequest.h"
 #include "model/QueryZnodeDetailResult.h"
+#include "model/RemoveApplicationRequest.h"
+#include "model/RemoveApplicationResult.h"
+#include "model/RemoveAuthPolicyRequest.h"
+#include "model/RemoveAuthPolicyResult.h"
 #include "model/RestartClusterRequest.h"
 #include "model/RestartClusterResult.h"
 #include "model/RetryClusterRequest.h"
@@ -290,8 +340,12 @@
 #include "model/UntagResourcesResult.h"
 #include "model/UpdateAclRequest.h"
 #include "model/UpdateAclResult.h"
+#include "model/UpdateAuthPolicyRequest.h"
+#include "model/UpdateAuthPolicyResult.h"
 #include "model/UpdateBlackWhiteListRequest.h"
 #include "model/UpdateBlackWhiteListResult.h"
+#include "model/UpdateCircuitBreakerRuleRequest.h"
+#include "model/UpdateCircuitBreakerRuleResult.h"
 #include "model/UpdateClusterRequest.h"
 #include "model/UpdateClusterResult.h"
 #include "model/UpdateClusterSpecRequest.h"
@@ -300,6 +354,16 @@
 #include "model/UpdateConfigResult.h"
 #include "model/UpdateEngineNamespaceRequest.h"
 #include "model/UpdateEngineNamespaceResult.h"
+#include "model/UpdateFlowRuleRequest.h"
+#include "model/UpdateFlowRuleResult.h"
+#include "model/UpdateGatewayAuthConsumerRequest.h"
+#include "model/UpdateGatewayAuthConsumerResult.h"
+#include "model/UpdateGatewayAuthConsumerResourceRequest.h"
+#include "model/UpdateGatewayAuthConsumerResourceResult.h"
+#include "model/UpdateGatewayAuthConsumerResourceStatusRequest.h"
+#include "model/UpdateGatewayAuthConsumerResourceStatusResult.h"
+#include "model/UpdateGatewayAuthConsumerStatusRequest.h"
+#include "model/UpdateGatewayAuthConsumerStatusResult.h"
 #include "model/UpdateGatewayDomainRequest.h"
 #include "model/UpdateGatewayDomainResult.h"
 #include "model/UpdateGatewayNameRequest.h"
@@ -308,6 +372,8 @@
 #include "model/UpdateGatewayOptionResult.h"
 #include "model/UpdateGatewayRouteRequest.h"
 #include "model/UpdateGatewayRouteResult.h"
+#include "model/UpdateGatewayRouteAuthRequest.h"
+#include "model/UpdateGatewayRouteAuthResult.h"
 #include "model/UpdateGatewayRouteCORSRequest.h"
 #include "model/UpdateGatewayRouteCORSResult.h"
 #include "model/UpdateGatewayRouteHTTPRewriteRequest.h"
@@ -359,6 +425,9 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_MSE_EXPORT MseClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::AddAuthPolicyResult> AddAuthPolicyOutcome;
+			typedef std::future<AddAuthPolicyOutcome> AddAuthPolicyOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::AddAuthPolicyRequest&, const AddAuthPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddAuthPolicyAsyncHandler;
 			typedef Outcome<Error, Model::AddAuthResourceResult> AddAuthResourceOutcome;
 			typedef std::future<AddAuthResourceOutcome> AddAuthResourceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::AddAuthResourceRequest&, const AddAuthResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddAuthResourceAsyncHandler;
@@ -368,6 +437,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AddGatewayResult> AddGatewayOutcome;
 			typedef std::future<AddGatewayOutcome> AddGatewayOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::AddGatewayRequest&, const AddGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddGatewayAsyncHandler;
+			typedef Outcome<Error, Model::AddGatewayAuthConsumerResult> AddGatewayAuthConsumerOutcome;
+			typedef std::future<AddGatewayAuthConsumerOutcome> AddGatewayAuthConsumerOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::AddGatewayAuthConsumerRequest&, const AddGatewayAuthConsumerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddGatewayAuthConsumerAsyncHandler;
 			typedef Outcome<Error, Model::AddGatewayDomainResult> AddGatewayDomainOutcome;
 			typedef std::future<AddGatewayDomainOutcome> AddGatewayDomainOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::AddGatewayDomainRequest&, const AddGatewayDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddGatewayDomainAsyncHandler;
@@ -407,12 +479,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateApplicationResult> CreateApplicationOutcome;
 			typedef std::future<CreateApplicationOutcome> CreateApplicationOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::CreateApplicationRequest&, const CreateApplicationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateApplicationAsyncHandler;
+			typedef Outcome<Error, Model::CreateCircuitBreakerRuleResult> CreateCircuitBreakerRuleOutcome;
+			typedef std::future<CreateCircuitBreakerRuleOutcome> CreateCircuitBreakerRuleOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::CreateCircuitBreakerRuleRequest&, const CreateCircuitBreakerRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCircuitBreakerRuleAsyncHandler;
 			typedef Outcome<Error, Model::CreateClusterResult> CreateClusterOutcome;
 			typedef std::future<CreateClusterOutcome> CreateClusterOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::CreateClusterRequest&, const CreateClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateClusterAsyncHandler;
 			typedef Outcome<Error, Model::CreateEngineNamespaceResult> CreateEngineNamespaceOutcome;
 			typedef std::future<CreateEngineNamespaceOutcome> CreateEngineNamespaceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::CreateEngineNamespaceRequest&, const CreateEngineNamespaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateEngineNamespaceAsyncHandler;
+			typedef Outcome<Error, Model::CreateFlowRuleResult> CreateFlowRuleOutcome;
+			typedef std::future<CreateFlowRuleOutcome> CreateFlowRuleOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::CreateFlowRuleRequest&, const CreateFlowRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFlowRuleAsyncHandler;
 			typedef Outcome<Error, Model::CreateMseServiceApplicationResult> CreateMseServiceApplicationOutcome;
 			typedef std::future<CreateMseServiceApplicationOutcome> CreateMseServiceApplicationOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::CreateMseServiceApplicationRequest&, const CreateMseServiceApplicationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMseServiceApplicationAsyncHandler;
@@ -437,15 +515,27 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteAuthResourceResult> DeleteAuthResourceOutcome;
 			typedef std::future<DeleteAuthResourceOutcome> DeleteAuthResourceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::DeleteAuthResourceRequest&, const DeleteAuthResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAuthResourceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteCircuitBreakerRulesResult> DeleteCircuitBreakerRulesOutcome;
+			typedef std::future<DeleteCircuitBreakerRulesOutcome> DeleteCircuitBreakerRulesOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::DeleteCircuitBreakerRulesRequest&, const DeleteCircuitBreakerRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCircuitBreakerRulesAsyncHandler;
 			typedef Outcome<Error, Model::DeleteClusterResult> DeleteClusterOutcome;
 			typedef std::future<DeleteClusterOutcome> DeleteClusterOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::DeleteClusterRequest&, const DeleteClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteClusterAsyncHandler;
 			typedef Outcome<Error, Model::DeleteEngineNamespaceResult> DeleteEngineNamespaceOutcome;
 			typedef std::future<DeleteEngineNamespaceOutcome> DeleteEngineNamespaceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::DeleteEngineNamespaceRequest&, const DeleteEngineNamespaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteEngineNamespaceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteFlowRulesResult> DeleteFlowRulesOutcome;
+			typedef std::future<DeleteFlowRulesOutcome> DeleteFlowRulesOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::DeleteFlowRulesRequest&, const DeleteFlowRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFlowRulesAsyncHandler;
 			typedef Outcome<Error, Model::DeleteGatewayResult> DeleteGatewayOutcome;
 			typedef std::future<DeleteGatewayOutcome> DeleteGatewayOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::DeleteGatewayRequest&, const DeleteGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayAsyncHandler;
+			typedef Outcome<Error, Model::DeleteGatewayAuthConsumerResult> DeleteGatewayAuthConsumerOutcome;
+			typedef std::future<DeleteGatewayAuthConsumerOutcome> DeleteGatewayAuthConsumerOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::DeleteGatewayAuthConsumerRequest&, const DeleteGatewayAuthConsumerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayAuthConsumerAsyncHandler;
+			typedef Outcome<Error, Model::DeleteGatewayAuthConsumerResourceResult> DeleteGatewayAuthConsumerResourceOutcome;
+			typedef std::future<DeleteGatewayAuthConsumerResourceOutcome> DeleteGatewayAuthConsumerResourceOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::DeleteGatewayAuthConsumerResourceRequest&, const DeleteGatewayAuthConsumerResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayAuthConsumerResourceAsyncHandler;
 			typedef Outcome<Error, Model::DeleteGatewayDomainResult> DeleteGatewayDomainOutcome;
 			typedef std::future<DeleteGatewayDomainOutcome> DeleteGatewayDomainOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::DeleteGatewayDomainRequest&, const DeleteGatewayDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayDomainAsyncHandler;
@@ -476,6 +566,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteNacosServiceResult> DeleteNacosServiceOutcome;
 			typedef std::future<DeleteNacosServiceOutcome> DeleteNacosServiceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::DeleteNacosServiceRequest&, const DeleteNacosServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNacosServiceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteNamespaceResult> DeleteNamespaceOutcome;
+			typedef std::future<DeleteNamespaceOutcome> DeleteNamespaceOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::DeleteNamespaceRequest&, const DeleteNamespaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNamespaceAsyncHandler;
 			typedef Outcome<Error, Model::DeleteSecurityGroupRuleResult> DeleteSecurityGroupRuleOutcome;
 			typedef std::future<DeleteSecurityGroupRuleOutcome> DeleteSecurityGroupRuleOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::DeleteSecurityGroupRuleRequest&, const DeleteSecurityGroupRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSecurityGroupRuleAsyncHandler;
@@ -494,6 +587,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ExportNacosConfigResult> ExportNacosConfigOutcome;
 			typedef std::future<ExportNacosConfigOutcome> ExportNacosConfigOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ExportNacosConfigRequest&, const ExportNacosConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExportNacosConfigAsyncHandler;
+			typedef Outcome<Error, Model::ExportZookeeperDataResult> ExportZookeeperDataOutcome;
+			typedef std::future<ExportZookeeperDataOutcome> ExportZookeeperDataOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ExportZookeeperDataRequest&, const ExportZookeeperDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExportZookeeperDataAsyncHandler;
+			typedef Outcome<Error, Model::FetchLosslessRuleListResult> FetchLosslessRuleListOutcome;
+			typedef std::future<FetchLosslessRuleListOutcome> FetchLosslessRuleListOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::FetchLosslessRuleListRequest&, const FetchLosslessRuleListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FetchLosslessRuleListAsyncHandler;
 			typedef Outcome<Error, Model::GetAppMessageQueueRouteResult> GetAppMessageQueueRouteOutcome;
 			typedef std::future<GetAppMessageQueueRouteOutcome> GetAppMessageQueueRouteOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::GetAppMessageQueueRouteRequest&, const GetAppMessageQueueRouteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAppMessageQueueRouteAsyncHandler;
@@ -512,6 +611,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetGatewayResult> GetGatewayOutcome;
 			typedef std::future<GetGatewayOutcome> GetGatewayOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::GetGatewayRequest&, const GetGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetGatewayAsyncHandler;
+			typedef Outcome<Error, Model::GetGatewayAuthConsumerDetailResult> GetGatewayAuthConsumerDetailOutcome;
+			typedef std::future<GetGatewayAuthConsumerDetailOutcome> GetGatewayAuthConsumerDetailOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::GetGatewayAuthConsumerDetailRequest&, const GetGatewayAuthConsumerDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetGatewayAuthConsumerDetailAsyncHandler;
 			typedef Outcome<Error, Model::GetGatewayDomainDetailResult> GetGatewayDomainDetailOutcome;
 			typedef std::future<GetGatewayDomainDetailOutcome> GetGatewayDomainDetailOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::GetGatewayDomainDetailRequest&, const GetGatewayDomainDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetGatewayDomainDetailAsyncHandler;
@@ -536,6 +638,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetKubernetesSourceResult> GetKubernetesSourceOutcome;
 			typedef std::future<GetKubernetesSourceOutcome> GetKubernetesSourceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::GetKubernetesSourceRequest&, const GetKubernetesSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetKubernetesSourceAsyncHandler;
+			typedef Outcome<Error, Model::GetLosslessRuleByAppResult> GetLosslessRuleByAppOutcome;
+			typedef std::future<GetLosslessRuleByAppOutcome> GetLosslessRuleByAppOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::GetLosslessRuleByAppRequest&, const GetLosslessRuleByAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLosslessRuleByAppAsyncHandler;
 			typedef Outcome<Error, Model::GetMseFeatureSwitchResult> GetMseFeatureSwitchOutcome;
 			typedef std::future<GetMseFeatureSwitchOutcome> GetMseFeatureSwitchOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::GetMseFeatureSwitchRequest&, const GetMseFeatureSwitchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMseFeatureSwitchAsyncHandler;
@@ -560,9 +665,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetServiceListResult> GetServiceListOutcome;
 			typedef std::future<GetServiceListOutcome> GetServiceListOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::GetServiceListRequest&, const GetServiceListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetServiceListAsyncHandler;
+			typedef Outcome<Error, Model::GetServiceListPageResult> GetServiceListPageOutcome;
+			typedef std::future<GetServiceListPageOutcome> GetServiceListPageOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::GetServiceListPageRequest&, const GetServiceListPageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetServiceListPageAsyncHandler;
 			typedef Outcome<Error, Model::GetServiceListenersResult> GetServiceListenersOutcome;
 			typedef std::future<GetServiceListenersOutcome> GetServiceListenersOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::GetServiceListenersRequest&, const GetServiceListenersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetServiceListenersAsyncHandler;
+			typedef Outcome<Error, Model::GetServiceMethodPageResult> GetServiceMethodPageOutcome;
+			typedef std::future<GetServiceMethodPageOutcome> GetServiceMethodPageOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::GetServiceMethodPageRequest&, const GetServiceMethodPageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetServiceMethodPageAsyncHandler;
 			typedef Outcome<Error, Model::GetTagsBySwimmingLaneGroupIdResult> GetTagsBySwimmingLaneGroupIdOutcome;
 			typedef std::future<GetTagsBySwimmingLaneGroupIdOutcome> GetTagsBySwimmingLaneGroupIdOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::GetTagsBySwimmingLaneGroupIdRequest&, const GetTagsBySwimmingLaneGroupIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTagsBySwimmingLaneGroupIdAsyncHandler;
@@ -593,6 +704,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListApplicationsWithTagRulesResult> ListApplicationsWithTagRulesOutcome;
 			typedef std::future<ListApplicationsWithTagRulesOutcome> ListApplicationsWithTagRulesOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListApplicationsWithTagRulesRequest&, const ListApplicationsWithTagRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListApplicationsWithTagRulesAsyncHandler;
+			typedef Outcome<Error, Model::ListAuthPolicyResult> ListAuthPolicyOutcome;
+			typedef std::future<ListAuthPolicyOutcome> ListAuthPolicyOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ListAuthPolicyRequest&, const ListAuthPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAuthPolicyAsyncHandler;
+			typedef Outcome<Error, Model::ListCircuitBreakerRulesResult> ListCircuitBreakerRulesOutcome;
+			typedef std::future<ListCircuitBreakerRulesOutcome> ListCircuitBreakerRulesOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ListCircuitBreakerRulesRequest&, const ListCircuitBreakerRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCircuitBreakerRulesAsyncHandler;
 			typedef Outcome<Error, Model::ListClusterConnectionTypesResult> ListClusterConnectionTypesOutcome;
 			typedef std::future<ListClusterConnectionTypesOutcome> ListClusterConnectionTypesOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListClusterConnectionTypesRequest&, const ListClusterConnectionTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClusterConnectionTypesAsyncHandler;
@@ -620,15 +737,30 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListEurekaServicesResult> ListEurekaServicesOutcome;
 			typedef std::future<ListEurekaServicesOutcome> ListEurekaServicesOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListEurekaServicesRequest&, const ListEurekaServicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListEurekaServicesAsyncHandler;
+			typedef Outcome<Error, Model::ListExportZookeeperDataResult> ListExportZookeeperDataOutcome;
+			typedef std::future<ListExportZookeeperDataOutcome> ListExportZookeeperDataOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ListExportZookeeperDataRequest&, const ListExportZookeeperDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListExportZookeeperDataAsyncHandler;
+			typedef Outcome<Error, Model::ListFlowRulesResult> ListFlowRulesOutcome;
+			typedef std::future<ListFlowRulesOutcome> ListFlowRulesOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ListFlowRulesRequest&, const ListFlowRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFlowRulesAsyncHandler;
 			typedef Outcome<Error, Model::ListGatewayResult> ListGatewayOutcome;
 			typedef std::future<ListGatewayOutcome> ListGatewayOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListGatewayRequest&, const ListGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListGatewayAsyncHandler;
+			typedef Outcome<Error, Model::ListGatewayAuthConsumerResult> ListGatewayAuthConsumerOutcome;
+			typedef std::future<ListGatewayAuthConsumerOutcome> ListGatewayAuthConsumerOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ListGatewayAuthConsumerRequest&, const ListGatewayAuthConsumerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListGatewayAuthConsumerAsyncHandler;
+			typedef Outcome<Error, Model::ListGatewayAuthConsumerResourceResult> ListGatewayAuthConsumerResourceOutcome;
+			typedef std::future<ListGatewayAuthConsumerResourceOutcome> ListGatewayAuthConsumerResourceOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ListGatewayAuthConsumerResourceRequest&, const ListGatewayAuthConsumerResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListGatewayAuthConsumerResourceAsyncHandler;
 			typedef Outcome<Error, Model::ListGatewayDomainResult> ListGatewayDomainOutcome;
 			typedef std::future<ListGatewayDomainOutcome> ListGatewayDomainOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListGatewayDomainRequest&, const ListGatewayDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListGatewayDomainAsyncHandler;
 			typedef Outcome<Error, Model::ListGatewayRouteResult> ListGatewayRouteOutcome;
 			typedef std::future<ListGatewayRouteOutcome> ListGatewayRouteOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListGatewayRouteRequest&, const ListGatewayRouteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListGatewayRouteAsyncHandler;
+			typedef Outcome<Error, Model::ListGatewayRouteOnAuthResult> ListGatewayRouteOnAuthOutcome;
+			typedef std::future<ListGatewayRouteOnAuthOutcome> ListGatewayRouteOnAuthOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ListGatewayRouteOnAuthRequest&, const ListGatewayRouteOnAuthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListGatewayRouteOnAuthAsyncHandler;
 			typedef Outcome<Error, Model::ListGatewayServiceResult> ListGatewayServiceOutcome;
 			typedef std::future<ListGatewayServiceOutcome> ListGatewayServiceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListGatewayServiceRequest&, const ListGatewayServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListGatewayServiceAsyncHandler;
@@ -734,6 +866,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::QueryMonitorResult> QueryMonitorOutcome;
 			typedef std::future<QueryMonitorOutcome> QueryMonitorOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::QueryMonitorRequest&, const QueryMonitorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryMonitorAsyncHandler;
+			typedef Outcome<Error, Model::QueryNamespaceResult> QueryNamespaceOutcome;
+			typedef std::future<QueryNamespaceOutcome> QueryNamespaceOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::QueryNamespaceRequest&, const QueryNamespaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryNamespaceAsyncHandler;
 			typedef Outcome<Error, Model::QuerySlbSpecResult> QuerySlbSpecOutcome;
 			typedef std::future<QuerySlbSpecOutcome> QuerySlbSpecOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::QuerySlbSpecRequest&, const QuerySlbSpecOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QuerySlbSpecAsyncHandler;
@@ -743,6 +878,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::QueryZnodeDetailResult> QueryZnodeDetailOutcome;
 			typedef std::future<QueryZnodeDetailOutcome> QueryZnodeDetailOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::QueryZnodeDetailRequest&, const QueryZnodeDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryZnodeDetailAsyncHandler;
+			typedef Outcome<Error, Model::RemoveApplicationResult> RemoveApplicationOutcome;
+			typedef std::future<RemoveApplicationOutcome> RemoveApplicationOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::RemoveApplicationRequest&, const RemoveApplicationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveApplicationAsyncHandler;
+			typedef Outcome<Error, Model::RemoveAuthPolicyResult> RemoveAuthPolicyOutcome;
+			typedef std::future<RemoveAuthPolicyOutcome> RemoveAuthPolicyOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::RemoveAuthPolicyRequest&, const RemoveAuthPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveAuthPolicyAsyncHandler;
 			typedef Outcome<Error, Model::RestartClusterResult> RestartClusterOutcome;
 			typedef std::future<RestartClusterOutcome> RestartClusterOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::RestartClusterRequest&, const RestartClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartClusterAsyncHandler;
@@ -761,9 +902,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateAclResult> UpdateAclOutcome;
 			typedef std::future<UpdateAclOutcome> UpdateAclOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::UpdateAclRequest&, const UpdateAclOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAclAsyncHandler;
+			typedef Outcome<Error, Model::UpdateAuthPolicyResult> UpdateAuthPolicyOutcome;
+			typedef std::future<UpdateAuthPolicyOutcome> UpdateAuthPolicyOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateAuthPolicyRequest&, const UpdateAuthPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAuthPolicyAsyncHandler;
 			typedef Outcome<Error, Model::UpdateBlackWhiteListResult> UpdateBlackWhiteListOutcome;
 			typedef std::future<UpdateBlackWhiteListOutcome> UpdateBlackWhiteListOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::UpdateBlackWhiteListRequest&, const UpdateBlackWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateBlackWhiteListAsyncHandler;
+			typedef Outcome<Error, Model::UpdateCircuitBreakerRuleResult> UpdateCircuitBreakerRuleOutcome;
+			typedef std::future<UpdateCircuitBreakerRuleOutcome> UpdateCircuitBreakerRuleOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateCircuitBreakerRuleRequest&, const UpdateCircuitBreakerRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateCircuitBreakerRuleAsyncHandler;
 			typedef Outcome<Error, Model::UpdateClusterResult> UpdateClusterOutcome;
 			typedef std::future<UpdateClusterOutcome> UpdateClusterOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::UpdateClusterRequest&, const UpdateClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateClusterAsyncHandler;
@@ -776,6 +923,21 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateEngineNamespaceResult> UpdateEngineNamespaceOutcome;
 			typedef std::future<UpdateEngineNamespaceOutcome> UpdateEngineNamespaceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::UpdateEngineNamespaceRequest&, const UpdateEngineNamespaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateEngineNamespaceAsyncHandler;
+			typedef Outcome<Error, Model::UpdateFlowRuleResult> UpdateFlowRuleOutcome;
+			typedef std::future<UpdateFlowRuleOutcome> UpdateFlowRuleOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateFlowRuleRequest&, const UpdateFlowRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateFlowRuleAsyncHandler;
+			typedef Outcome<Error, Model::UpdateGatewayAuthConsumerResult> UpdateGatewayAuthConsumerOutcome;
+			typedef std::future<UpdateGatewayAuthConsumerOutcome> UpdateGatewayAuthConsumerOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateGatewayAuthConsumerRequest&, const UpdateGatewayAuthConsumerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayAuthConsumerAsyncHandler;
+			typedef Outcome<Error, Model::UpdateGatewayAuthConsumerResourceResult> UpdateGatewayAuthConsumerResourceOutcome;
+			typedef std::future<UpdateGatewayAuthConsumerResourceOutcome> UpdateGatewayAuthConsumerResourceOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateGatewayAuthConsumerResourceRequest&, const UpdateGatewayAuthConsumerResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayAuthConsumerResourceAsyncHandler;
+			typedef Outcome<Error, Model::UpdateGatewayAuthConsumerResourceStatusResult> UpdateGatewayAuthConsumerResourceStatusOutcome;
+			typedef std::future<UpdateGatewayAuthConsumerResourceStatusOutcome> UpdateGatewayAuthConsumerResourceStatusOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateGatewayAuthConsumerResourceStatusRequest&, const UpdateGatewayAuthConsumerResourceStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayAuthConsumerResourceStatusAsyncHandler;
+			typedef Outcome<Error, Model::UpdateGatewayAuthConsumerStatusResult> UpdateGatewayAuthConsumerStatusOutcome;
+			typedef std::future<UpdateGatewayAuthConsumerStatusOutcome> UpdateGatewayAuthConsumerStatusOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateGatewayAuthConsumerStatusRequest&, const UpdateGatewayAuthConsumerStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayAuthConsumerStatusAsyncHandler;
 			typedef Outcome<Error, Model::UpdateGatewayDomainResult> UpdateGatewayDomainOutcome;
 			typedef std::future<UpdateGatewayDomainOutcome> UpdateGatewayDomainOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::UpdateGatewayDomainRequest&, const UpdateGatewayDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayDomainAsyncHandler;
@@ -788,6 +950,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateGatewayRouteResult> UpdateGatewayRouteOutcome;
 			typedef std::future<UpdateGatewayRouteOutcome> UpdateGatewayRouteOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::UpdateGatewayRouteRequest&, const UpdateGatewayRouteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayRouteAsyncHandler;
+			typedef Outcome<Error, Model::UpdateGatewayRouteAuthResult> UpdateGatewayRouteAuthOutcome;
+			typedef std::future<UpdateGatewayRouteAuthOutcome> UpdateGatewayRouteAuthOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateGatewayRouteAuthRequest&, const UpdateGatewayRouteAuthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayRouteAuthAsyncHandler;
 			typedef Outcome<Error, Model::UpdateGatewayRouteCORSResult> UpdateGatewayRouteCORSOutcome;
 			typedef std::future<UpdateGatewayRouteCORSOutcome> UpdateGatewayRouteCORSOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::UpdateGatewayRouteCORSRequest&, const UpdateGatewayRouteCORSOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayRouteCORSAsyncHandler;
@@ -856,6 +1021,9 @@ namespace AlibabaCloud
 			MseClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			MseClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~MseClient();
+			AddAuthPolicyOutcome addAuthPolicy(const Model::AddAuthPolicyRequest &request)const;
+			void addAuthPolicyAsync(const Model::AddAuthPolicyRequest& request, const AddAuthPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddAuthPolicyOutcomeCallable addAuthPolicyCallable(const Model::AddAuthPolicyRequest& request) const;
 			AddAuthResourceOutcome addAuthResource(const Model::AddAuthResourceRequest &request)const;
 			void addAuthResourceAsync(const Model::AddAuthResourceRequest& request, const AddAuthResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddAuthResourceOutcomeCallable addAuthResourceCallable(const Model::AddAuthResourceRequest& request) const;
@@ -865,6 +1033,9 @@ namespace AlibabaCloud
 			AddGatewayOutcome addGateway(const Model::AddGatewayRequest &request)const;
 			void addGatewayAsync(const Model::AddGatewayRequest& request, const AddGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddGatewayOutcomeCallable addGatewayCallable(const Model::AddGatewayRequest& request) const;
+			AddGatewayAuthConsumerOutcome addGatewayAuthConsumer(const Model::AddGatewayAuthConsumerRequest &request)const;
+			void addGatewayAuthConsumerAsync(const Model::AddGatewayAuthConsumerRequest& request, const AddGatewayAuthConsumerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddGatewayAuthConsumerOutcomeCallable addGatewayAuthConsumerCallable(const Model::AddGatewayAuthConsumerRequest& request) const;
 			AddGatewayDomainOutcome addGatewayDomain(const Model::AddGatewayDomainRequest &request)const;
 			void addGatewayDomainAsync(const Model::AddGatewayDomainRequest& request, const AddGatewayDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddGatewayDomainOutcomeCallable addGatewayDomainCallable(const Model::AddGatewayDomainRequest& request) const;
@@ -904,12 +1075,18 @@ namespace AlibabaCloud
 			CreateApplicationOutcome createApplication(const Model::CreateApplicationRequest &request)const;
 			void createApplicationAsync(const Model::CreateApplicationRequest& request, const CreateApplicationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateApplicationOutcomeCallable createApplicationCallable(const Model::CreateApplicationRequest& request) const;
+			CreateCircuitBreakerRuleOutcome createCircuitBreakerRule(const Model::CreateCircuitBreakerRuleRequest &request)const;
+			void createCircuitBreakerRuleAsync(const Model::CreateCircuitBreakerRuleRequest& request, const CreateCircuitBreakerRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateCircuitBreakerRuleOutcomeCallable createCircuitBreakerRuleCallable(const Model::CreateCircuitBreakerRuleRequest& request) const;
 			CreateClusterOutcome createCluster(const Model::CreateClusterRequest &request)const;
 			void createClusterAsync(const Model::CreateClusterRequest& request, const CreateClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateClusterOutcomeCallable createClusterCallable(const Model::CreateClusterRequest& request) const;
 			CreateEngineNamespaceOutcome createEngineNamespace(const Model::CreateEngineNamespaceRequest &request)const;
 			void createEngineNamespaceAsync(const Model::CreateEngineNamespaceRequest& request, const CreateEngineNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateEngineNamespaceOutcomeCallable createEngineNamespaceCallable(const Model::CreateEngineNamespaceRequest& request) const;
+			CreateFlowRuleOutcome createFlowRule(const Model::CreateFlowRuleRequest &request)const;
+			void createFlowRuleAsync(const Model::CreateFlowRuleRequest& request, const CreateFlowRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateFlowRuleOutcomeCallable createFlowRuleCallable(const Model::CreateFlowRuleRequest& request) const;
 			CreateMseServiceApplicationOutcome createMseServiceApplication(const Model::CreateMseServiceApplicationRequest &request)const;
 			void createMseServiceApplicationAsync(const Model::CreateMseServiceApplicationRequest& request, const CreateMseServiceApplicationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateMseServiceApplicationOutcomeCallable createMseServiceApplicationCallable(const Model::CreateMseServiceApplicationRequest& request) const;
@@ -934,15 +1111,27 @@ namespace AlibabaCloud
 			DeleteAuthResourceOutcome deleteAuthResource(const Model::DeleteAuthResourceRequest &request)const;
 			void deleteAuthResourceAsync(const Model::DeleteAuthResourceRequest& request, const DeleteAuthResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteAuthResourceOutcomeCallable deleteAuthResourceCallable(const Model::DeleteAuthResourceRequest& request) const;
+			DeleteCircuitBreakerRulesOutcome deleteCircuitBreakerRules(const Model::DeleteCircuitBreakerRulesRequest &request)const;
+			void deleteCircuitBreakerRulesAsync(const Model::DeleteCircuitBreakerRulesRequest& request, const DeleteCircuitBreakerRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteCircuitBreakerRulesOutcomeCallable deleteCircuitBreakerRulesCallable(const Model::DeleteCircuitBreakerRulesRequest& request) const;
 			DeleteClusterOutcome deleteCluster(const Model::DeleteClusterRequest &request)const;
 			void deleteClusterAsync(const Model::DeleteClusterRequest& request, const DeleteClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteClusterOutcomeCallable deleteClusterCallable(const Model::DeleteClusterRequest& request) const;
 			DeleteEngineNamespaceOutcome deleteEngineNamespace(const Model::DeleteEngineNamespaceRequest &request)const;
 			void deleteEngineNamespaceAsync(const Model::DeleteEngineNamespaceRequest& request, const DeleteEngineNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteEngineNamespaceOutcomeCallable deleteEngineNamespaceCallable(const Model::DeleteEngineNamespaceRequest& request) const;
+			DeleteFlowRulesOutcome deleteFlowRules(const Model::DeleteFlowRulesRequest &request)const;
+			void deleteFlowRulesAsync(const Model::DeleteFlowRulesRequest& request, const DeleteFlowRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteFlowRulesOutcomeCallable deleteFlowRulesCallable(const Model::DeleteFlowRulesRequest& request) const;
 			DeleteGatewayOutcome deleteGateway(const Model::DeleteGatewayRequest &request)const;
 			void deleteGatewayAsync(const Model::DeleteGatewayRequest& request, const DeleteGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteGatewayOutcomeCallable deleteGatewayCallable(const Model::DeleteGatewayRequest& request) const;
+			DeleteGatewayAuthConsumerOutcome deleteGatewayAuthConsumer(const Model::DeleteGatewayAuthConsumerRequest &request)const;
+			void deleteGatewayAuthConsumerAsync(const Model::DeleteGatewayAuthConsumerRequest& request, const DeleteGatewayAuthConsumerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteGatewayAuthConsumerOutcomeCallable deleteGatewayAuthConsumerCallable(const Model::DeleteGatewayAuthConsumerRequest& request) const;
+			DeleteGatewayAuthConsumerResourceOutcome deleteGatewayAuthConsumerResource(const Model::DeleteGatewayAuthConsumerResourceRequest &request)const;
+			void deleteGatewayAuthConsumerResourceAsync(const Model::DeleteGatewayAuthConsumerResourceRequest& request, const DeleteGatewayAuthConsumerResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteGatewayAuthConsumerResourceOutcomeCallable deleteGatewayAuthConsumerResourceCallable(const Model::DeleteGatewayAuthConsumerResourceRequest& request) const;
 			DeleteGatewayDomainOutcome deleteGatewayDomain(const Model::DeleteGatewayDomainRequest &request)const;
 			void deleteGatewayDomainAsync(const Model::DeleteGatewayDomainRequest& request, const DeleteGatewayDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteGatewayDomainOutcomeCallable deleteGatewayDomainCallable(const Model::DeleteGatewayDomainRequest& request) const;
@@ -973,6 +1162,9 @@ namespace AlibabaCloud
 			DeleteNacosServiceOutcome deleteNacosService(const Model::DeleteNacosServiceRequest &request)const;
 			void deleteNacosServiceAsync(const Model::DeleteNacosServiceRequest& request, const DeleteNacosServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteNacosServiceOutcomeCallable deleteNacosServiceCallable(const Model::DeleteNacosServiceRequest& request) const;
+			DeleteNamespaceOutcome deleteNamespace(const Model::DeleteNamespaceRequest &request)const;
+			void deleteNamespaceAsync(const Model::DeleteNamespaceRequest& request, const DeleteNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteNamespaceOutcomeCallable deleteNamespaceCallable(const Model::DeleteNamespaceRequest& request) const;
 			DeleteSecurityGroupRuleOutcome deleteSecurityGroupRule(const Model::DeleteSecurityGroupRuleRequest &request)const;
 			void deleteSecurityGroupRuleAsync(const Model::DeleteSecurityGroupRuleRequest& request, const DeleteSecurityGroupRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteSecurityGroupRuleOutcomeCallable deleteSecurityGroupRuleCallable(const Model::DeleteSecurityGroupRuleRequest& request) const;
@@ -991,6 +1183,12 @@ namespace AlibabaCloud
 			ExportNacosConfigOutcome exportNacosConfig(const Model::ExportNacosConfigRequest &request)const;
 			void exportNacosConfigAsync(const Model::ExportNacosConfigRequest& request, const ExportNacosConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ExportNacosConfigOutcomeCallable exportNacosConfigCallable(const Model::ExportNacosConfigRequest& request) const;
+			ExportZookeeperDataOutcome exportZookeeperData(const Model::ExportZookeeperDataRequest &request)const;
+			void exportZookeeperDataAsync(const Model::ExportZookeeperDataRequest& request, const ExportZookeeperDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ExportZookeeperDataOutcomeCallable exportZookeeperDataCallable(const Model::ExportZookeeperDataRequest& request) const;
+			FetchLosslessRuleListOutcome fetchLosslessRuleList(const Model::FetchLosslessRuleListRequest &request)const;
+			void fetchLosslessRuleListAsync(const Model::FetchLosslessRuleListRequest& request, const FetchLosslessRuleListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			FetchLosslessRuleListOutcomeCallable fetchLosslessRuleListCallable(const Model::FetchLosslessRuleListRequest& request) const;
 			GetAppMessageQueueRouteOutcome getAppMessageQueueRoute(const Model::GetAppMessageQueueRouteRequest &request)const;
 			void getAppMessageQueueRouteAsync(const Model::GetAppMessageQueueRouteRequest& request, const GetAppMessageQueueRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetAppMessageQueueRouteOutcomeCallable getAppMessageQueueRouteCallable(const Model::GetAppMessageQueueRouteRequest& request) const;
@@ -1009,6 +1207,9 @@ namespace AlibabaCloud
 			GetGatewayOutcome getGateway(const Model::GetGatewayRequest &request)const;
 			void getGatewayAsync(const Model::GetGatewayRequest& request, const GetGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetGatewayOutcomeCallable getGatewayCallable(const Model::GetGatewayRequest& request) const;
+			GetGatewayAuthConsumerDetailOutcome getGatewayAuthConsumerDetail(const Model::GetGatewayAuthConsumerDetailRequest &request)const;
+			void getGatewayAuthConsumerDetailAsync(const Model::GetGatewayAuthConsumerDetailRequest& request, const GetGatewayAuthConsumerDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetGatewayAuthConsumerDetailOutcomeCallable getGatewayAuthConsumerDetailCallable(const Model::GetGatewayAuthConsumerDetailRequest& request) const;
 			GetGatewayDomainDetailOutcome getGatewayDomainDetail(const Model::GetGatewayDomainDetailRequest &request)const;
 			void getGatewayDomainDetailAsync(const Model::GetGatewayDomainDetailRequest& request, const GetGatewayDomainDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetGatewayDomainDetailOutcomeCallable getGatewayDomainDetailCallable(const Model::GetGatewayDomainDetailRequest& request) const;
@@ -1033,6 +1234,9 @@ namespace AlibabaCloud
 			GetKubernetesSourceOutcome getKubernetesSource(const Model::GetKubernetesSourceRequest &request)const;
 			void getKubernetesSourceAsync(const Model::GetKubernetesSourceRequest& request, const GetKubernetesSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetKubernetesSourceOutcomeCallable getKubernetesSourceCallable(const Model::GetKubernetesSourceRequest& request) const;
+			GetLosslessRuleByAppOutcome getLosslessRuleByApp(const Model::GetLosslessRuleByAppRequest &request)const;
+			void getLosslessRuleByAppAsync(const Model::GetLosslessRuleByAppRequest& request, const GetLosslessRuleByAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetLosslessRuleByAppOutcomeCallable getLosslessRuleByAppCallable(const Model::GetLosslessRuleByAppRequest& request) const;
 			GetMseFeatureSwitchOutcome getMseFeatureSwitch(const Model::GetMseFeatureSwitchRequest &request)const;
 			void getMseFeatureSwitchAsync(const Model::GetMseFeatureSwitchRequest& request, const GetMseFeatureSwitchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetMseFeatureSwitchOutcomeCallable getMseFeatureSwitchCallable(const Model::GetMseFeatureSwitchRequest& request) const;
@@ -1057,9 +1261,15 @@ namespace AlibabaCloud
 			GetServiceListOutcome getServiceList(const Model::GetServiceListRequest &request)const;
 			void getServiceListAsync(const Model::GetServiceListRequest& request, const GetServiceListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetServiceListOutcomeCallable getServiceListCallable(const Model::GetServiceListRequest& request) const;
+			GetServiceListPageOutcome getServiceListPage(const Model::GetServiceListPageRequest &request)const;
+			void getServiceListPageAsync(const Model::GetServiceListPageRequest& request, const GetServiceListPageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetServiceListPageOutcomeCallable getServiceListPageCallable(const Model::GetServiceListPageRequest& request) const;
 			GetServiceListenersOutcome getServiceListeners(const Model::GetServiceListenersRequest &request)const;
 			void getServiceListenersAsync(const Model::GetServiceListenersRequest& request, const GetServiceListenersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetServiceListenersOutcomeCallable getServiceListenersCallable(const Model::GetServiceListenersRequest& request) const;
+			GetServiceMethodPageOutcome getServiceMethodPage(const Model::GetServiceMethodPageRequest &request)const;
+			void getServiceMethodPageAsync(const Model::GetServiceMethodPageRequest& request, const GetServiceMethodPageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetServiceMethodPageOutcomeCallable getServiceMethodPageCallable(const Model::GetServiceMethodPageRequest& request) const;
 			GetTagsBySwimmingLaneGroupIdOutcome getTagsBySwimmingLaneGroupId(const Model::GetTagsBySwimmingLaneGroupIdRequest &request)const;
 			void getTagsBySwimmingLaneGroupIdAsync(const Model::GetTagsBySwimmingLaneGroupIdRequest& request, const GetTagsBySwimmingLaneGroupIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetTagsBySwimmingLaneGroupIdOutcomeCallable getTagsBySwimmingLaneGroupIdCallable(const Model::GetTagsBySwimmingLaneGroupIdRequest& request) const;
@@ -1090,6 +1300,12 @@ namespace AlibabaCloud
 			ListApplicationsWithTagRulesOutcome listApplicationsWithTagRules(const Model::ListApplicationsWithTagRulesRequest &request)const;
 			void listApplicationsWithTagRulesAsync(const Model::ListApplicationsWithTagRulesRequest& request, const ListApplicationsWithTagRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListApplicationsWithTagRulesOutcomeCallable listApplicationsWithTagRulesCallable(const Model::ListApplicationsWithTagRulesRequest& request) const;
+			ListAuthPolicyOutcome listAuthPolicy(const Model::ListAuthPolicyRequest &request)const;
+			void listAuthPolicyAsync(const Model::ListAuthPolicyRequest& request, const ListAuthPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAuthPolicyOutcomeCallable listAuthPolicyCallable(const Model::ListAuthPolicyRequest& request) const;
+			ListCircuitBreakerRulesOutcome listCircuitBreakerRules(const Model::ListCircuitBreakerRulesRequest &request)const;
+			void listCircuitBreakerRulesAsync(const Model::ListCircuitBreakerRulesRequest& request, const ListCircuitBreakerRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListCircuitBreakerRulesOutcomeCallable listCircuitBreakerRulesCallable(const Model::ListCircuitBreakerRulesRequest& request) const;
 			ListClusterConnectionTypesOutcome listClusterConnectionTypes(const Model::ListClusterConnectionTypesRequest &request)const;
 			void listClusterConnectionTypesAsync(const Model::ListClusterConnectionTypesRequest& request, const ListClusterConnectionTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListClusterConnectionTypesOutcomeCallable listClusterConnectionTypesCallable(const Model::ListClusterConnectionTypesRequest& request) const;
@@ -1117,15 +1333,30 @@ namespace AlibabaCloud
 			ListEurekaServicesOutcome listEurekaServices(const Model::ListEurekaServicesRequest &request)const;
 			void listEurekaServicesAsync(const Model::ListEurekaServicesRequest& request, const ListEurekaServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListEurekaServicesOutcomeCallable listEurekaServicesCallable(const Model::ListEurekaServicesRequest& request) const;
+			ListExportZookeeperDataOutcome listExportZookeeperData(const Model::ListExportZookeeperDataRequest &request)const;
+			void listExportZookeeperDataAsync(const Model::ListExportZookeeperDataRequest& request, const ListExportZookeeperDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListExportZookeeperDataOutcomeCallable listExportZookeeperDataCallable(const Model::ListExportZookeeperDataRequest& request) const;
+			ListFlowRulesOutcome listFlowRules(const Model::ListFlowRulesRequest &request)const;
+			void listFlowRulesAsync(const Model::ListFlowRulesRequest& request, const ListFlowRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListFlowRulesOutcomeCallable listFlowRulesCallable(const Model::ListFlowRulesRequest& request) const;
 			ListGatewayOutcome listGateway(const Model::ListGatewayRequest &request)const;
 			void listGatewayAsync(const Model::ListGatewayRequest& request, const ListGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListGatewayOutcomeCallable listGatewayCallable(const Model::ListGatewayRequest& request) const;
+			ListGatewayAuthConsumerOutcome listGatewayAuthConsumer(const Model::ListGatewayAuthConsumerRequest &request)const;
+			void listGatewayAuthConsumerAsync(const Model::ListGatewayAuthConsumerRequest& request, const ListGatewayAuthConsumerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListGatewayAuthConsumerOutcomeCallable listGatewayAuthConsumerCallable(const Model::ListGatewayAuthConsumerRequest& request) const;
+			ListGatewayAuthConsumerResourceOutcome listGatewayAuthConsumerResource(const Model::ListGatewayAuthConsumerResourceRequest &request)const;
+			void listGatewayAuthConsumerResourceAsync(const Model::ListGatewayAuthConsumerResourceRequest& request, const ListGatewayAuthConsumerResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListGatewayAuthConsumerResourceOutcomeCallable listGatewayAuthConsumerResourceCallable(const Model::ListGatewayAuthConsumerResourceRequest& request) const;
 			ListGatewayDomainOutcome listGatewayDomain(const Model::ListGatewayDomainRequest &request)const;
 			void listGatewayDomainAsync(const Model::ListGatewayDomainRequest& request, const ListGatewayDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListGatewayDomainOutcomeCallable listGatewayDomainCallable(const Model::ListGatewayDomainRequest& request) const;
 			ListGatewayRouteOutcome listGatewayRoute(const Model::ListGatewayRouteRequest &request)const;
 			void listGatewayRouteAsync(const Model::ListGatewayRouteRequest& request, const ListGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListGatewayRouteOutcomeCallable listGatewayRouteCallable(const Model::ListGatewayRouteRequest& request) const;
+			ListGatewayRouteOnAuthOutcome listGatewayRouteOnAuth(const Model::ListGatewayRouteOnAuthRequest &request)const;
+			void listGatewayRouteOnAuthAsync(const Model::ListGatewayRouteOnAuthRequest& request, const ListGatewayRouteOnAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListGatewayRouteOnAuthOutcomeCallable listGatewayRouteOnAuthCallable(const Model::ListGatewayRouteOnAuthRequest& request) const;
 			ListGatewayServiceOutcome listGatewayService(const Model::ListGatewayServiceRequest &request)const;
 			void listGatewayServiceAsync(const Model::ListGatewayServiceRequest& request, const ListGatewayServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListGatewayServiceOutcomeCallable listGatewayServiceCallable(const Model::ListGatewayServiceRequest& request) const;
@@ -1231,6 +1462,9 @@ namespace AlibabaCloud
 			QueryMonitorOutcome queryMonitor(const Model::QueryMonitorRequest &request)const;
 			void queryMonitorAsync(const Model::QueryMonitorRequest& request, const QueryMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryMonitorOutcomeCallable queryMonitorCallable(const Model::QueryMonitorRequest& request) const;
+			QueryNamespaceOutcome queryNamespace(const Model::QueryNamespaceRequest &request)const;
+			void queryNamespaceAsync(const Model::QueryNamespaceRequest& request, const QueryNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryNamespaceOutcomeCallable queryNamespaceCallable(const Model::QueryNamespaceRequest& request) const;
 			QuerySlbSpecOutcome querySlbSpec(const Model::QuerySlbSpecRequest &request)const;
 			void querySlbSpecAsync(const Model::QuerySlbSpecRequest& request, const QuerySlbSpecAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QuerySlbSpecOutcomeCallable querySlbSpecCallable(const Model::QuerySlbSpecRequest& request) const;
@@ -1240,6 +1474,12 @@ namespace AlibabaCloud
 			QueryZnodeDetailOutcome queryZnodeDetail(const Model::QueryZnodeDetailRequest &request)const;
 			void queryZnodeDetailAsync(const Model::QueryZnodeDetailRequest& request, const QueryZnodeDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryZnodeDetailOutcomeCallable queryZnodeDetailCallable(const Model::QueryZnodeDetailRequest& request) const;
+			RemoveApplicationOutcome removeApplication(const Model::RemoveApplicationRequest &request)const;
+			void removeApplicationAsync(const Model::RemoveApplicationRequest& request, const RemoveApplicationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveApplicationOutcomeCallable removeApplicationCallable(const Model::RemoveApplicationRequest& request) const;
+			RemoveAuthPolicyOutcome removeAuthPolicy(const Model::RemoveAuthPolicyRequest &request)const;
+			void removeAuthPolicyAsync(const Model::RemoveAuthPolicyRequest& request, const RemoveAuthPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveAuthPolicyOutcomeCallable removeAuthPolicyCallable(const Model::RemoveAuthPolicyRequest& request) const;
 			RestartClusterOutcome restartCluster(const Model::RestartClusterRequest &request)const;
 			void restartClusterAsync(const Model::RestartClusterRequest& request, const RestartClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RestartClusterOutcomeCallable restartClusterCallable(const Model::RestartClusterRequest& request) const;
@@ -1258,9 +1498,15 @@ namespace AlibabaCloud
 			UpdateAclOutcome updateAcl(const Model::UpdateAclRequest &request)const;
 			void updateAclAsync(const Model::UpdateAclRequest& request, const UpdateAclAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateAclOutcomeCallable updateAclCallable(const Model::UpdateAclRequest& request) const;
+			UpdateAuthPolicyOutcome updateAuthPolicy(const Model::UpdateAuthPolicyRequest &request)const;
+			void updateAuthPolicyAsync(const Model::UpdateAuthPolicyRequest& request, const UpdateAuthPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateAuthPolicyOutcomeCallable updateAuthPolicyCallable(const Model::UpdateAuthPolicyRequest& request) const;
 			UpdateBlackWhiteListOutcome updateBlackWhiteList(const Model::UpdateBlackWhiteListRequest &request)const;
 			void updateBlackWhiteListAsync(const Model::UpdateBlackWhiteListRequest& request, const UpdateBlackWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateBlackWhiteListOutcomeCallable updateBlackWhiteListCallable(const Model::UpdateBlackWhiteListRequest& request) const;
+			UpdateCircuitBreakerRuleOutcome updateCircuitBreakerRule(const Model::UpdateCircuitBreakerRuleRequest &request)const;
+			void updateCircuitBreakerRuleAsync(const Model::UpdateCircuitBreakerRuleRequest& request, const UpdateCircuitBreakerRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateCircuitBreakerRuleOutcomeCallable updateCircuitBreakerRuleCallable(const Model::UpdateCircuitBreakerRuleRequest& request) const;
 			UpdateClusterOutcome updateCluster(const Model::UpdateClusterRequest &request)const;
 			void updateClusterAsync(const Model::UpdateClusterRequest& request, const UpdateClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateClusterOutcomeCallable updateClusterCallable(const Model::UpdateClusterRequest& request) const;
@@ -1273,6 +1519,21 @@ namespace AlibabaCloud
 			UpdateEngineNamespaceOutcome updateEngineNamespace(const Model::UpdateEngineNamespaceRequest &request)const;
 			void updateEngineNamespaceAsync(const Model::UpdateEngineNamespaceRequest& request, const UpdateEngineNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateEngineNamespaceOutcomeCallable updateEngineNamespaceCallable(const Model::UpdateEngineNamespaceRequest& request) const;
+			UpdateFlowRuleOutcome updateFlowRule(const Model::UpdateFlowRuleRequest &request)const;
+			void updateFlowRuleAsync(const Model::UpdateFlowRuleRequest& request, const UpdateFlowRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateFlowRuleOutcomeCallable updateFlowRuleCallable(const Model::UpdateFlowRuleRequest& request) const;
+			UpdateGatewayAuthConsumerOutcome updateGatewayAuthConsumer(const Model::UpdateGatewayAuthConsumerRequest &request)const;
+			void updateGatewayAuthConsumerAsync(const Model::UpdateGatewayAuthConsumerRequest& request, const UpdateGatewayAuthConsumerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateGatewayAuthConsumerOutcomeCallable updateGatewayAuthConsumerCallable(const Model::UpdateGatewayAuthConsumerRequest& request) const;
+			UpdateGatewayAuthConsumerResourceOutcome updateGatewayAuthConsumerResource(const Model::UpdateGatewayAuthConsumerResourceRequest &request)const;
+			void updateGatewayAuthConsumerResourceAsync(const Model::UpdateGatewayAuthConsumerResourceRequest& request, const UpdateGatewayAuthConsumerResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateGatewayAuthConsumerResourceOutcomeCallable updateGatewayAuthConsumerResourceCallable(const Model::UpdateGatewayAuthConsumerResourceRequest& request) const;
+			UpdateGatewayAuthConsumerResourceStatusOutcome updateGatewayAuthConsumerResourceStatus(const Model::UpdateGatewayAuthConsumerResourceStatusRequest &request)const;
+			void updateGatewayAuthConsumerResourceStatusAsync(const Model::UpdateGatewayAuthConsumerResourceStatusRequest& request, const UpdateGatewayAuthConsumerResourceStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateGatewayAuthConsumerResourceStatusOutcomeCallable updateGatewayAuthConsumerResourceStatusCallable(const Model::UpdateGatewayAuthConsumerResourceStatusRequest& request) const;
+			UpdateGatewayAuthConsumerStatusOutcome updateGatewayAuthConsumerStatus(const Model::UpdateGatewayAuthConsumerStatusRequest &request)const;
+			void updateGatewayAuthConsumerStatusAsync(const Model::UpdateGatewayAuthConsumerStatusRequest& request, const UpdateGatewayAuthConsumerStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateGatewayAuthConsumerStatusOutcomeCallable updateGatewayAuthConsumerStatusCallable(const Model::UpdateGatewayAuthConsumerStatusRequest& request) const;
 			UpdateGatewayDomainOutcome updateGatewayDomain(const Model::UpdateGatewayDomainRequest &request)const;
 			void updateGatewayDomainAsync(const Model::UpdateGatewayDomainRequest& request, const UpdateGatewayDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateGatewayDomainOutcomeCallable updateGatewayDomainCallable(const Model::UpdateGatewayDomainRequest& request) const;
@@ -1285,6 +1546,9 @@ namespace AlibabaCloud
 			UpdateGatewayRouteOutcome updateGatewayRoute(const Model::UpdateGatewayRouteRequest &request)const;
 			void updateGatewayRouteAsync(const Model::UpdateGatewayRouteRequest& request, const UpdateGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateGatewayRouteOutcomeCallable updateGatewayRouteCallable(const Model::UpdateGatewayRouteRequest& request) const;
+			UpdateGatewayRouteAuthOutcome updateGatewayRouteAuth(const Model::UpdateGatewayRouteAuthRequest &request)const;
+			void updateGatewayRouteAuthAsync(const Model::UpdateGatewayRouteAuthRequest& request, const UpdateGatewayRouteAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateGatewayRouteAuthOutcomeCallable updateGatewayRouteAuthCallable(const Model::UpdateGatewayRouteAuthRequest& request) const;
 			UpdateGatewayRouteCORSOutcome updateGatewayRouteCORS(const Model::UpdateGatewayRouteCORSRequest &request)const;
 			void updateGatewayRouteCORSAsync(const Model::UpdateGatewayRouteCORSRequest& request, const UpdateGatewayRouteCORSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateGatewayRouteCORSOutcomeCallable updateGatewayRouteCORSCallable(const Model::UpdateGatewayRouteCORSRequest& request) const;

mse/include/alibabacloud/mse/model/AddAuthPolicyRequest.h

@@ -0,0 +1,75 @@
+/*
+ * 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_MSE_MODEL_ADDAUTHPOLICYREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_ADDAUTHPOLICYREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT AddAuthPolicyRequest : public RpcServiceRequest {
+public:
+	AddAuthPolicyRequest();
+	~AddAuthPolicyRequest();
+	std::string getMseSessionId() const;
+	void setMseSessionId(const std::string &mseSessionId);
+	std::string getAuthRule() const;
+	void setAuthRule(const std::string &authRule);
+	std::string getSource() const;
+	void setSource(const std::string &source);
+	int getAuthType() const;
+	void setAuthType(int authType);
+	std::string getProtocol() const;
+	void setProtocol(const std::string &protocol);
+	std::string getEnable() const;
+	void setEnable(const std::string &enable);
+	std::string getK8sNamespace() const;
+	void setK8sNamespace(const std::string &k8sNamespace);
+	std::string getAppId() const;
+	void setAppId(const std::string &appId);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getRegion() const;
+	void setRegion(const std::string &region);
+
+private:
+	std::string mseSessionId_;
+	std::string authRule_;
+	std::string source_;
+	int authType_;
+	std::string protocol_;
+	std::string enable_;
+	std::string k8sNamespace_;
+	std::string appId_;
+	std::string name_;
+	std::string _namespace_;
+	std::string acceptLanguage_;
+	std::string region_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_ADDAUTHPOLICYREQUEST_H_

mse/include/alibabacloud/mse/model/AddAuthPolicyResult.h

@@ -0,0 +1,59 @@
+/*
+ * 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_MSE_MODEL_ADDAUTHPOLICYRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_ADDAUTHPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT AddAuthPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				AddAuthPolicyResult();
+				explicit AddAuthPolicyResult(const std::string &payload);
+				~AddAuthPolicyResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_ADDAUTHPOLICYRESULT_H_

mse/include/alibabacloud/mse/model/AddGatewayAuthConsumerRequest.h

@@ -0,0 +1,81 @@
+/*
+ * 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_MSE_MODEL_ADDGATEWAYAUTHCONSUMERREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_ADDGATEWAYAUTHCONSUMERREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT AddGatewayAuthConsumerRequest : public RpcServiceRequest {
+public:
+	AddGatewayAuthConsumerRequest();
+	~AddGatewayAuthConsumerRequest();
+	std::string getMseSessionId() const;
+	void setMseSessionId(const std::string &mseSessionId);
+	std::string getType() const;
+	void setType(const std::string &type);
+	std::string getKeyName() const;
+	void setKeyName(const std::string &keyName);
+	std::string getTokenPrefix() const;
+	void setTokenPrefix(const std::string &tokenPrefix);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	std::string getJwks() const;
+	void setJwks(const std::string &jwks);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getTokenPosition() const;
+	void setTokenPosition(const std::string &tokenPosition);
+	std::string getEncodeType() const;
+	void setEncodeType(const std::string &encodeType);
+	std::string getKeyValue() const;
+	void setKeyValue(const std::string &keyValue);
+	bool getTokenPass() const;
+	void setTokenPass(bool tokenPass);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getTokenName() const;
+	void setTokenName(const std::string &tokenName);
+
+private:
+	std::string mseSessionId_;
+	std::string type_;
+	std::string keyName_;
+	std::string tokenPrefix_;
+	std::string name_;
+	std::string gatewayUniqueId_;
+	std::string jwks_;
+	std::string description_;
+	std::string tokenPosition_;
+	std::string encodeType_;
+	std::string keyValue_;
+	bool tokenPass_;
+	std::string acceptLanguage_;
+	std::string tokenName_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_ADDGATEWAYAUTHCONSUMERREQUEST_H_

mse/include/alibabacloud/mse/model/AddGatewayAuthConsumerResult.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_MSE_MODEL_ADDGATEWAYAUTHCONSUMERRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_ADDGATEWAYAUTHCONSUMERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT AddGatewayAuthConsumerResult : public ServiceResult
+			{
+			public:
+
+
+				AddGatewayAuthConsumerResult();
+				explicit AddGatewayAuthConsumerResult(const std::string &payload);
+				~AddGatewayAuthConsumerResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				long getData()const;
+				std::string getErrorCode()const;
+				std::string getDynamicMessage()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				long data_;
+				std::string errorCode_;
+				std::string dynamicMessage_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_ADDGATEWAYAUTHCONSUMERRESULT_H_

mse/include/alibabacloud/mse/model/AddGatewayRequest.h

@@ -32,6 +32,10 @@ public:
 		std::string value;
 		std::string key;
 	};
+	struct ZoneInfo {
+		std::string vSwitchId;
+		std::string zoneId;
+	};
 	AddGatewayRequest();
 	~AddGatewayRequest();
 	std::string getMseSessionId() const;
@@ -40,12 +44,8 @@ public:
 	void setInternetSlbSpec(const std::string &internetSlbSpec);
 	bool getEnableXtrace() const;
 	void setEnableXtrace(bool enableXtrace);
-	std::string getXtraceRatio() const;
-	void setXtraceRatio(const std::string &xtraceRatio);
 	int getReplica() const;
 	void setReplica(int replica);
-	std::string getVSwitchId2() const;
-	void setVSwitchId2(const std::string &vSwitchId2);
 	bool getEnableHardwareAcceleration() const;
 	void setEnableHardwareAcceleration(bool enableHardwareAcceleration);
 	bool getEnableSls() const;
@@ -54,42 +54,55 @@ public:
 	void setSpec(const std::string &spec);
 	std::string getResourceGroupId() const;
 	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getRequestPars() const;
+	void setRequestPars(const std::string &requestPars);
 	bool getEnterpriseSecurityGroup() const;
 	void setEnterpriseSecurityGroup(bool enterpriseSecurityGroup);
 	std::vector<Tag> getTag() const;
 	void setTag(const std::vector<Tag> &tag);
-	std::string getVpc() const;
-	void setVpc(const std::string &vpc);
 	std::string getVSwitchId() const;
 	void setVSwitchId(const std::string &vSwitchId);
 	std::string getSlbSpec() const;
 	void setSlbSpec(const std::string &slbSpec);
 	std::string getName() const;
 	void setName(const std::string &name);
-	std::string getAcceptLanguage() const;
-	void setAcceptLanguage(const std::string &acceptLanguage);
 	std::string getRegion() const;
 	void setRegion(const std::string &region);
+	std::vector<ZoneInfo> getZoneInfo() const;
+	void setZoneInfo(const std::vector<ZoneInfo> &zoneInfo);
+	std::string getXtraceRatio() const;
+	void setXtraceRatio(const std::string &xtraceRatio);
+	std::string getVSwitchId2() const;
+	void setVSwitchId2(const std::string &vSwitchId2);
+	std::string getVpc() const;
+	void setVpc(const std::string &vpc);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getChargeType() const;
+	void setChargeType(const std::string &chargeType);
 
 private:
 	std::string mseSessionId_;
 	std::string internetSlbSpec_;
 	bool enableXtrace_;
-	std::string xtraceRatio_;
 	int replica_;
-	std::string vSwitchId2_;
 	bool enableHardwareAcceleration_;
 	bool enableSls_;
 	std::string spec_;
 	std::string resourceGroupId_;
+	std::string requestPars_;
 	bool enterpriseSecurityGroup_;
 	std::vector<Tag> tag_;
-	std::string vpc_;
 	std::string vSwitchId_;
 	std::string slbSpec_;
 	std::string name_;
-	std::string acceptLanguage_;
 	std::string region_;
+	std::vector<ZoneInfo> zoneInfo_;
+	std::string xtraceRatio_;
+	std::string vSwitchId2_;
+	std::string vpc_;
+	std::string acceptLanguage_;
+	std::string chargeType_;
 };
 } // namespace Model
 } // namespace Mse

mse/include/alibabacloud/mse/model/AddGatewayRouteRequest.h

@@ -28,6 +28,45 @@ namespace Mse {
 namespace Model {
 class ALIBABACLOUD_MSE_EXPORT AddGatewayRouteRequest : public RpcServiceRequest {
 public:
+	struct Predicates {
+		struct PathPredicates {
+			std::string path;
+			bool ignoreCase;
+			std::string type;
+		};
+		PathPredicates pathPredicates;
+		std::string string;
+		std::vector<std::string> methodPredicates;
+		struct HeaderPredicatesItem {
+			std::string type;
+			std::string value;
+			std::string key;
+		};
+		HeaderPredicatesItem headerPredicatesItem;
+		std::vector<HeaderPredicatesItem> headerPredicates;
+		struct QueryPredicatesItem {
+			std::string type;
+			std::string value;
+			std::string key;
+		};
+		QueryPredicatesItem queryPredicatesItem;
+		std::vector<QueryPredicatesItem> queryPredicates;
+	};
+	struct DirectResponseJSON {
+		long code;
+		std::string body;
+	};
+	struct FallbackServices {
+		std::string agreementType;
+		std::string name;
+		std::string _namespace;
+		std::string sourceType;
+		long serviceId;
+		int percent;
+		std::string version;
+		std::string groupName;
+		int servicePort;
+	};
 	struct Services {
 		struct HttpDubboTranscoder {
 			std::string dubboServiceName;
@@ -62,102 +101,69 @@ public:
 		std::string groupName;
 		int servicePort;
 	};
-	struct Predicates {
-		struct PathPredicates {
-			std::string path;
-			bool ignoreCase;
-			std::string type;
-		};
-		PathPredicates pathPredicates;
-		std::string string;
-		std::vector<std::string> methodPredicates;
-		struct HeaderPredicatesItem {
-			std::string type;
-			std::string value;
-			std::string key;
-		};
-		HeaderPredicatesItem headerPredicatesItem;
-		std::vector<HeaderPredicatesItem> headerPredicates;
-		struct QueryPredicatesItem {
-			std::string type;
-			std::string value;
-			std::string key;
-		};
-		QueryPredicatesItem queryPredicatesItem;
-		std::vector<QueryPredicatesItem> queryPredicates;
-	};
 	struct RedirectJSON {
 		std::string path;
 		int code;
 		std::string host;
 	};
-	struct DirectResponseJSON {
-		long code;
-		std::string body;
-	};
-	struct FallbackServices {
-		std::string agreementType;
-		std::string name;
-		std::string _namespace;
-		std::string sourceType;
-		long serviceId;
-		int percent;
-		std::string version;
-		std::string groupName;
-		int servicePort;
-	};
 	AddGatewayRouteRequest();
 	~AddGatewayRouteRequest();
 	std::string getMseSessionId() const;
 	void setMseSessionId(const std::string &mseSessionId);
-	std::string getGatewayUniqueId() const;
-	void setGatewayUniqueId(const std::string &gatewayUniqueId);
-	std::string getDestinationType() const;
-	void setDestinationType(const std::string &destinationType);
 	std::string getDomainIdListJSON() const;
 	void setDomainIdListJSON(const std::string &domainIdListJSON);
 	long getDomainId() const;
 	void setDomainId(long domainId);
+	std::string getRouteType() const;
+	void setRouteType(const std::string &routeType);
 	long getGatewayId() const;
 	void setGatewayId(long gatewayId);
-	int getRouteOrder() const;
-	void setRouteOrder(int routeOrder);
 	bool getEnableWaf() const;
 	void setEnableWaf(bool enableWaf);
-	std::vector<Services> getServices() const;
-	void setServices(const std::vector<Services> &services);
 	Predicates getPredicates() const;
 	void setPredicates(const Predicates &predicates);
-	RedirectJSON getRedirectJSON() const;
-	void setRedirectJSON(const RedirectJSON &redirectJSON);
 	DirectResponseJSON getDirectResponseJSON() const;
 	void setDirectResponseJSON(const DirectResponseJSON &directResponseJSON);
 	std::string getName() const;
 	void setName(const std::string &name);
-	std::string getAcceptLanguage() const;
-	void setAcceptLanguage(const std::string &acceptLanguage);
 	std::vector<FallbackServices> getFallbackServices() const;
 	void setFallbackServices(const std::vector<FallbackServices> &fallbackServices);
 	bool getFallback() const;
 	void setFallback(bool fallback);
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	std::string getDestinationType() const;
+	void setDestinationType(const std::string &destinationType);
+	std::string getPolicies() const;
+	void setPolicies(const std::string &policies);
+	int getRouteOrder() const;
+	void setRouteOrder(int routeOrder);
+	std::vector<Services> getServices() const;
+	void setServices(const std::vector<Services> &services);
+	RedirectJSON getRedirectJSON() const;
+	void setRedirectJSON(const RedirectJSON &redirectJSON);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
 
 private:
 	std::string mseSessionId_;
-	std::string gatewayUniqueId_;
-	std::string destinationType_;
 	std::string domainIdListJSON_;
 	long domainId_;
+	std::string routeType_;
 	long gatewayId_;
-	int routeOrder_;
 	bool enableWaf_;
-	std::vector<Services> services_;
 	Predicates predicates_;
-	RedirectJSON redirectJSON_;
 	DirectResponseJSON directResponseJSON_;
 	std::string name_;
-	std::string acceptLanguage_;
 	std::vector<FallbackServices> fallbackServices_;
 	bool fallback_;
+	std::string gatewayUniqueId_;
+	std::string destinationType_;
+	std::string policies_;
+	int routeOrder_;
+	std::vector<Services> services_;
+	RedirectJSON redirectJSON_;
+	std::string acceptLanguage_;
 };
 } // namespace Model
 } // namespace Mse

mse/include/alibabacloud/mse/model/AddGatewayRouteResult.h

@@ -40,6 +40,7 @@ namespace AlibabaCloud
 				std::string getMessage()const;
 				int getHttpStatusCode()const;
 				long getData()const;
+				std::string getErrorCode()const;
 				int getCode()const;
 				bool getSuccess()const;
 
@@ -49,6 +50,7 @@ namespace AlibabaCloud
 				std::string message_;
 				int httpStatusCode_;
 				long data_;
+				std::string errorCode_;
 				int code_;
 				bool success_;
 

mse/include/alibabacloud/mse/model/AddGatewaySlbRequest.h

@@ -28,6 +28,12 @@ namespace Mse {
 namespace Model {
 class ALIBABACLOUD_MSE_EXPORT AddGatewaySlbRequest : public RpcServiceRequest {
 public:
+	struct VServiceList {
+		std::string vServerGroupId;
+		std::string protocol;
+		int port;
+		std::string vServerGroupName;
+	};
 	AddGatewaySlbRequest();
 	~AddGatewaySlbRequest();
 	std::string getMseSessionId() const;
@@ -44,6 +50,8 @@ public:
 	void setServiceWeight(int serviceWeight);
 	std::string getVServerGroupId() const;
 	void setVServerGroupId(const std::string &vServerGroupId);
+	std::vector<VServiceList> getVServiceList() const;
+	void setVServiceList(const std::vector<VServiceList> &vServiceList);
 	std::string getHttpsVServerGroupId() const;
 	void setHttpsVServerGroupId(const std::string &httpsVServerGroupId);
 	std::string getAcceptLanguage() const;
@@ -59,6 +67,7 @@ private:
 	int httpPort_;
 	int serviceWeight_;
 	std::string vServerGroupId_;
+	std::vector<VServiceList> vServiceList_;
 	std::string httpsVServerGroupId_;
 	std::string acceptLanguage_;
 	int httpsPort_;

mse/include/alibabacloud/mse/model/AddMockRuleRequest.h

@@ -34,43 +34,43 @@ public:
 	void setMseSessionId(const std::string &mseSessionId);
 	std::string getExtraJson() const;
 	void setExtraJson(const std::string &extraJson);
-	std::string getProviderAppId() const;
-	void setProviderAppId(const std::string &providerAppId);
 	std::string getSource() const;
 	void setSource(const std::string &source);
 	bool getEnable() const;
 	void setEnable(bool enable);
 	std::string getScMockItems() const;
 	void setScMockItems(const std::string &scMockItems);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getRegion() const;
+	void setRegion(const std::string &region);
+	std::string getProviderAppId() const;
+	void setProviderAppId(const std::string &providerAppId);
 	std::string getProviderAppName() const;
 	void setProviderAppName(const std::string &providerAppName);
 	std::string getConsumerAppIds() const;
 	void setConsumerAppIds(const std::string &consumerAppIds);
 	std::string getDubboMockItems() const;
 	void setDubboMockItems(const std::string &dubboMockItems);
-	std::string getName() const;
-	void setName(const std::string &name);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
 	long getMockType() const;
 	void setMockType(long mockType);
-	std::string getRegion() const;
-	void setRegion(const std::string &region);
 
 private:
 	std::string mseSessionId_;
 	std::string extraJson_;
-	std::string providerAppId_;
 	std::string source_;
 	bool enable_;
 	std::string scMockItems_;
+	std::string name_;
+	std::string region_;
+	std::string providerAppId_;
 	std::string providerAppName_;
 	std::string consumerAppIds_;
 	std::string dubboMockItems_;
-	std::string name_;
 	std::string acceptLanguage_;
 	long mockType_;
-	std::string region_;
 };
 } // namespace Model
 } // namespace Mse

mse/include/alibabacloud/mse/model/ApplyTagPoliciesRequest.h

@@ -36,12 +36,16 @@ public:
 	void setRules(const std::string &rules);
 	std::string getSource() const;
 	void setSource(const std::string &source);
+	std::string getAppName() const;
+	void setAppName(const std::string &appName);
 	std::string getNamespaceId() const;
 	void setNamespaceId(const std::string &namespaceId);
 	bool getEnable() const;
 	void setEnable(bool enable);
 	std::string getAppId() const;
 	void setAppId(const std::string &appId);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
 	std::string getRegion() const;
@@ -51,9 +55,11 @@ private:
 	std::string mseSessionId_;
 	std::string rules_;
 	std::string source_;
+	std::string appName_;
 	std::string namespaceId_;
 	bool enable_;
 	std::string appId_;
+	std::string _namespace_;
 	std::string acceptLanguage_;
 	std::string region_;
 };

mse/include/alibabacloud/mse/model/CloneNacosConfigRequest.h

@@ -34,25 +34,25 @@ public:
 	void setMseSessionId(const std::string &mseSessionId);
 	std::string getTargetNamespaceId() const;
 	void setTargetNamespaceId(const std::string &targetNamespaceId);
+	std::string getOriginNamespaceId() const;
+	void setOriginNamespaceId(const std::string &originNamespaceId);
+	std::string getPolicy() const;
+	void setPolicy(const std::string &policy);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
 	std::string getIds() const;
 	void setIds(const std::string &ids);
-	std::string getOriginNamespaceId() const;
-	void setOriginNamespaceId(const std::string &originNamespaceId);
-	std::string getPolicy() const;
-	void setPolicy(const std::string &policy);
 
 private:
 	std::string mseSessionId_;
 	std::string targetNamespaceId_;
+	std::string originNamespaceId_;
+	std::string policy_;
 	std::string instanceId_;
 	std::string acceptLanguage_;
 	std::string ids_;
-	std::string originNamespaceId_;
-	std::string policy_;
 };
 } // namespace Model
 } // namespace Mse

mse/include/alibabacloud/mse/model/CreateCircuitBreakerRuleRequest.h

@@ -0,0 +1,87 @@
+/*
+ * 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_MSE_MODEL_CREATECIRCUITBREAKERRULEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_CREATECIRCUITBREAKERRULEREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT CreateCircuitBreakerRuleRequest : public RpcServiceRequest {
+public:
+	CreateCircuitBreakerRuleRequest();
+	~CreateCircuitBreakerRuleRequest();
+	std::string getMseSessionId() const;
+	void setMseSessionId(const std::string &mseSessionId);
+	float getThreshold() const;
+	void setThreshold(float threshold);
+	int getRetryTimeoutMs() const;
+	void setRetryTimeoutMs(int retryTimeoutMs);
+	std::string getAppName() const;
+	void setAppName(const std::string &appName);
+	bool getEnable() const;
+	void setEnable(bool enable);
+	int getMinRequestAmount() const;
+	void setMinRequestAmount(int minRequestAmount);
+	std::string getResource() const;
+	void setResource(const std::string &resource);
+	int getMaxAllowedRtMs() const;
+	void setMaxAllowedRtMs(int maxAllowedRtMs);
+	int getHalfOpenBaseAmountPerStep() const;
+	void setHalfOpenBaseAmountPerStep(int halfOpenBaseAmountPerStep);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getStatIntervalMs() const;
+	void setStatIntervalMs(int statIntervalMs);
+	std::string getAppId() const;
+	void setAppId(const std::string &appId);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+	int getHalfOpenRecoveryStepNum() const;
+	void setHalfOpenRecoveryStepNum(int halfOpenRecoveryStepNum);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	int getStrategy() const;
+	void setStrategy(int strategy);
+
+private:
+	std::string mseSessionId_;
+	float threshold_;
+	int retryTimeoutMs_;
+	std::string appName_;
+	bool enable_;
+	int minRequestAmount_;
+	std::string resource_;
+	int maxAllowedRtMs_;
+	int halfOpenBaseAmountPerStep_;
+	std::string regionId_;
+	int statIntervalMs_;
+	std::string appId_;
+	std::string _namespace_;
+	int halfOpenRecoveryStepNum_;
+	std::string acceptLanguage_;
+	int strategy_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_CREATECIRCUITBREAKERRULEREQUEST_H_

mse/include/alibabacloud/mse/model/CreateCircuitBreakerRuleResult.h

@@ -0,0 +1,75 @@
+/*
+ * 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_MSE_MODEL_CREATECIRCUITBREAKERRULERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_CREATECIRCUITBREAKERRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT CreateCircuitBreakerRuleResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					int minRequestAmount;
+					std::string resource;
+					std::string _namespace;
+					std::string appName;
+					int retryTimeoutMs;
+					std::string appId;
+					int halfOpenRecoveryStepNum;
+					bool enable;
+					int strategy;
+					int maxAllowedRtMs;
+					long id;
+					std::string regionId;
+					int halfOpenBaseAmountPerStep;
+					int statIntervalMs;
+					float threshold;
+				};
+
+
+				CreateCircuitBreakerRuleResult();
+				explicit CreateCircuitBreakerRuleResult(const std::string &payload);
+				~CreateCircuitBreakerRuleResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_CREATECIRCUITBREAKERRULERESULT_H_

mse/include/alibabacloud/mse/model/CreateClusterRequest.h

@@ -38,18 +38,30 @@ public:
 	void setClusterSpecification(const std::string &clusterSpecification);
 	std::string getMseSessionId() const;
 	void setMseSessionId(const std::string &mseSessionId);
-	std::string getPubSlbSpecification() const;
-	void setPubSlbSpecification(const std::string &pubSlbSpecification);
-	std::string getPrivateSlbSpecification() const;
-	void setPrivateSlbSpecification(const std::string &privateSlbSpecification);
 	std::string getResourceGroupId() const;
 	void setResourceGroupId(const std::string &resourceGroupId);
-	int getInstanceCount() const;
-	void setInstanceCount(int instanceCount);
 	std::string getRequestPars() const;
 	void setRequestPars(const std::string &requestPars);
 	std::vector<Tag> getTag() const;
 	void setTag(const std::vector<Tag> &tag);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
+	std::string getClusterType() const;
+	void setClusterType(const std::string &clusterType);
+	std::string getInstanceName() const;
+	void setInstanceName(const std::string &instanceName);
+	std::string getNetType() const;
+	void setNetType(const std::string &netType);
+	std::string getMseVersion() const;
+	void setMseVersion(const std::string &mseVersion);
+	std::string getRegion() const;
+	void setRegion(const std::string &region);
+	std::string getPubSlbSpecification() const;
+	void setPubSlbSpecification(const std::string &pubSlbSpecification);
+	std::string getPrivateSlbSpecification() const;
+	void setPrivateSlbSpecification(const std::string &privateSlbSpecification);
+	int getInstanceCount() const;
+	void setInstanceCount(int instanceCount);
 	std::string getConnectionType() const;
 	void setConnectionType(const std::string &connectionType);
 	std::string getClusterVersion() const;
@@ -58,47 +70,38 @@ public:
 	void setDiskCapacity(int diskCapacity);
 	std::string getDiskType() const;
 	void setDiskType(const std::string &diskType);
-	std::string getVSwitchId() const;
-	void setVSwitchId(const std::string &vSwitchId);
-	std::string getClusterType() const;
-	void setClusterType(const std::string &clusterType);
-	std::string getInstanceName() const;
-	void setInstanceName(const std::string &instanceName);
 	std::string getPubNetworkFlow() const;
 	void setPubNetworkFlow(const std::string &pubNetworkFlow);
 	std::string getVpcId() const;
 	void setVpcId(const std::string &vpcId);
-	std::string getNetType() const;
-	void setNetType(const std::string &netType);
-	std::string getMseVersion() const;
-	void setMseVersion(const std::string &mseVersion);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
-	std::string getRegion() const;
-	void setRegion(const std::string &region);
+	std::string getChargeType() const;
+	void setChargeType(const std::string &chargeType);
 
 private:
 	std::string clusterSpecification_;
 	std::string mseSessionId_;
-	std::string pubSlbSpecification_;
-	std::string privateSlbSpecification_;
 	std::string resourceGroupId_;
-	int instanceCount_;
 	std::string requestPars_;
 	std::vector<Tag> tag_;
+	std::string vSwitchId_;
+	std::string clusterType_;
+	std::string instanceName_;
+	std::string netType_;
+	std::string mseVersion_;
+	std::string region_;
+	std::string pubSlbSpecification_;
+	std::string privateSlbSpecification_;
+	int instanceCount_;
 	std::string connectionType_;
 	std::string clusterVersion_;
 	int diskCapacity_;
 	std::string diskType_;
-	std::string vSwitchId_;
-	std::string clusterType_;
-	std::string instanceName_;
 	std::string pubNetworkFlow_;
 	std::string vpcId_;
-	std::string netType_;
-	std::string mseVersion_;
 	std::string acceptLanguage_;
-	std::string region_;
+	std::string chargeType_;
 };
 } // namespace Model
 } // namespace Mse

mse/include/alibabacloud/mse/model/CreateEngineNamespaceRequest.h

@@ -32,29 +32,29 @@ public:
 	~CreateEngineNamespaceRequest();
 	std::string getMseSessionId() const;
 	void setMseSessionId(const std::string &mseSessionId);
+	int getServiceCount() const;
+	void setServiceCount(int serviceCount);
+	std::string getId() const;
+	void setId(const std::string &id);
 	std::string getClusterId() const;
 	void setClusterId(const std::string &clusterId);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
-	int getServiceCount() const;
-	void setServiceCount(int serviceCount);
 	std::string getName() const;
 	void setName(const std::string &name);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
-	std::string getId() const;
-	void setId(const std::string &id);
 	std::string getDesc() const;
 	void setDesc(const std::string &desc);
 
 private:
 	std::string mseSessionId_;
+	int serviceCount_;
+	std::string id_;
 	std::string clusterId_;
 	std::string instanceId_;
-	int serviceCount_;
 	std::string name_;
 	std::string acceptLanguage_;
-	std::string id_;
 	std::string desc_;
 };
 } // namespace Model

mse/include/alibabacloud/mse/model/CreateFlowRuleRequest.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_MSE_MODEL_CREATEFLOWRULEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_CREATEFLOWRULEREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT CreateFlowRuleRequest : public RpcServiceRequest {
+public:
+	CreateFlowRuleRequest();
+	~CreateFlowRuleRequest();
+	std::string getMseSessionId() const;
+	void setMseSessionId(const std::string &mseSessionId);
+	int getControlBehavior() const;
+	void setControlBehavior(int controlBehavior);
+	int getThreshold() const;
+	void setThreshold(int threshold);
+	std::string getAppName() const;
+	void setAppName(const std::string &appName);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getEnable() const;
+	void setEnable(bool enable);
+	std::string getResource() const;
+	void setResource(const std::string &resource);
+	std::string getAppId() const;
+	void setAppId(const std::string &appId);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	int getMaxQueueingTimeMs() const;
+	void setMaxQueueingTimeMs(int maxQueueingTimeMs);
+
+private:
+	std::string mseSessionId_;
+	int controlBehavior_;
+	int threshold_;
+	std::string appName_;
+	std::string regionId_;
+	bool enable_;
+	std::string resource_;
+	std::string appId_;
+	std::string _namespace_;
+	std::string acceptLanguage_;
+	int maxQueueingTimeMs_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_CREATEFLOWRULEREQUEST_H_

mse/include/alibabacloud/mse/model/CreateFlowRuleResult.h

@@ -0,0 +1,70 @@
+/*
+ * 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_MSE_MODEL_CREATEFLOWRULERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_CREATEFLOWRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT CreateFlowRuleResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string appId;
+					int controlBehavior;
+					std::string resource;
+					int maxQueueingTimeMs;
+					bool enable;
+					std::string _namespace;
+					long id;
+					std::string regionId;
+					std::string appName;
+					float threshold;
+				};
+
+
+				CreateFlowRuleResult();
+				explicit CreateFlowRuleResult(const std::string &payload);
+				~CreateFlowRuleResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_CREATEFLOWRULERESULT_H_

mse/include/alibabacloud/mse/model/CreateNacosInstanceRequest.h

@@ -38,12 +38,8 @@ public:
 	void setClusterName(const std::string &clusterName);
 	bool getEphemeral() const;
 	void setEphemeral(bool ephemeral);
-	bool getEnabled() const;
-	void setEnabled(bool enabled);
 	std::string getNamespaceId() const;
 	void setNamespaceId(const std::string &namespaceId);
-	std::string getServiceName() const;
-	void setServiceName(const std::string &serviceName);
 	std::string getIp() const;
 	void setIp(const std::string &ip);
 	std::string getWeight() const;
@@ -54,6 +50,10 @@ public:
 	void setInstanceId(const std::string &instanceId);
 	int getPort() const;
 	void setPort(int port);
+	bool getEnabled() const;
+	void setEnabled(bool enabled);
+	std::string getServiceName() const;
+	void setServiceName(const std::string &serviceName);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
 
@@ -62,14 +62,14 @@ private:
 	std::string metadata_;
 	std::string clusterName_;
 	bool ephemeral_;
-	bool enabled_;
 	std::string namespaceId_;
-	std::string serviceName_;
 	std::string ip_;
 	std::string weight_;
 	std::string groupName_;
 	std::string instanceId_;
 	int port_;
+	bool enabled_;
+	std::string serviceName_;
 	std::string acceptLanguage_;
 };
 } // namespace Model

mse/include/alibabacloud/mse/model/CreateNacosServiceRequest.h

@@ -34,30 +34,30 @@ public:
 	void setMseSessionId(const std::string &mseSessionId);
 	bool getEphemeral() const;
 	void setEphemeral(bool ephemeral);
+	std::string getNamespaceId() const;
+	void setNamespaceId(const std::string &namespaceId);
+	std::string getServiceName() const;
+	void setServiceName(const std::string &serviceName);
 	std::string getClusterId() const;
 	void setClusterId(const std::string &clusterId);
 	std::string getGroupName() const;
 	void setGroupName(const std::string &groupName);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
-	std::string getNamespaceId() const;
-	void setNamespaceId(const std::string &namespaceId);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
-	std::string getServiceName() const;
-	void setServiceName(const std::string &serviceName);
 	std::string getProtectThreshold() const;
 	void setProtectThreshold(const std::string &protectThreshold);
 
 private:
 	std::string mseSessionId_;
 	bool ephemeral_;
+	std::string namespaceId_;
+	std::string serviceName_;
 	std::string clusterId_;
 	std::string groupName_;
 	std::string instanceId_;
-	std::string namespaceId_;
 	std::string acceptLanguage_;
-	std::string serviceName_;
 	std::string protectThreshold_;
 };
 } // namespace Model

mse/include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneGroupRequest.h

@@ -32,60 +32,48 @@ public:
 	~CreateOrUpdateSwimmingLaneGroupRequest();
 	std::string getMseSessionId() const;
 	void setMseSessionId(const std::string &mseSessionId);
-	std::string getSource() const;
-	void setSource(const std::string &source);
-	std::string getGmtModified() const;
-	void setGmtModified(const std::string &gmtModified);
-	std::string getUserId() const;
-	void setUserId(const std::string &userId);
-	std::string getLicenseKey() const;
-	void setLicenseKey(const std::string &licenseKey);
 	std::string getAppIds() const;
 	void setAppIds(const std::string &appIds);
-	bool getMessageQueueGrayEnable() const;
-	void setMessageQueueGrayEnable(bool messageQueueGrayEnable);
 	bool getDbGrayEnable() const;
 	void setDbGrayEnable(bool dbGrayEnable);
 	bool getEnable() const;
 	void setEnable(bool enable);
-	std::string getEntryApp() const;
-	void setEntryApp(const std::string &entryApp);
 	long getId() const;
 	void setId(long id);
-	std::string getGmtCreate() const;
-	void setGmtCreate(const std::string &gmtCreate);
 	std::string getName() const;
 	void setName(const std::string &name);
 	std::string getMessageQueueFilterSide() const;
 	void setMessageQueueFilterSide(const std::string &messageQueueFilterSide);
-	std::string get_Namespace() const;
-	void set_Namespace(const std::string &_namespace);
-	std::string getAcceptLanguage() const;
-	void setAcceptLanguage(const std::string &acceptLanguage);
 	std::string getRegion() const;
 	void setRegion(const std::string &region);
 	int getStatus() const;
 	void setStatus(int status);
+	bool getMessageQueueGrayEnable() const;
+	void setMessageQueueGrayEnable(bool messageQueueGrayEnable);
+	std::string getEntryApp() const;
+	void setEntryApp(const std::string &entryApp);
+	bool getRecordCanaryDetail() const;
+	void setRecordCanaryDetail(bool recordCanaryDetail);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
 
 private:
 	std::string mseSessionId_;
-	std::string source_;
-	std::string gmtModified_;
-	std::string userId_;
-	std::string licenseKey_;
 	std::string appIds_;
-	bool messageQueueGrayEnable_;
 	bool dbGrayEnable_;
 	bool enable_;
-	std::string entryApp_;
 	long id_;
-	std::string gmtCreate_;
 	std::string name_;
 	std::string messageQueueFilterSide_;
-	std::string _namespace_;
-	std::string acceptLanguage_;
 	std::string region_;
 	int status_;
+	bool messageQueueGrayEnable_;
+	std::string entryApp_;
+	bool recordCanaryDetail_;
+	std::string _namespace_;
+	std::string acceptLanguage_;
 };
 } // namespace Model
 } // namespace Mse

mse/include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneGroupResult.h

@@ -32,15 +32,54 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_MSE_EXPORT CreateOrUpdateSwimmingLaneGroupResult : public ServiceResult
 			{
 			public:
+				struct Data
+				{
+					std::string region11;
+					int status13;
+					bool messageQueueGrayEnable;
+					std::string entryApp10;
+					std::string _namespace8;
+					std::string source;
+					std::string name;
+					std::string messageQueueFilterSide;
+					std::string enable;
+					std::vector<std::string> applicationList;
+					bool recordCanaryDetail;
+					std::string name1;
+					long id9;
+					std::string entryApp;
+					int status;
+					std::string messageQueueFilterSide5;
+					std::string _namespace;
+					std::string source3;
+					std::string dbGrayEnable;
+					std::string userId;
+					std::string region;
+					std::string dbGrayEnable2;
+					long id;
+					std::string enable7;
+					std::string userId4;
+					std::string appIds;
+					std::string appIds6;
+					bool messageQueueGrayEnable12;
+				};
 
 
 				CreateOrUpdateSwimmingLaneGroupResult();
 				explicit CreateOrUpdateSwimmingLaneGroupResult(const std::string &payload);
 				~CreateOrUpdateSwimmingLaneGroupResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getErrorCode()const;
+				bool getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string message_;
+				Data data_;
+				std::string errorCode_;
+				bool success_;
 
 			};
 		}

mse/include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneRequest.h

@@ -28,6 +28,22 @@ namespace Mse {
 namespace Model {
 class ALIBABACLOUD_MSE_EXPORT CreateOrUpdateSwimmingLaneRequest : public RpcServiceRequest {
 public:
+	struct EntryRules {
+		struct RestItems {
+			std::string datum;
+			int divisor;
+			int rate;
+			std::string name;
+			std::string type;
+			std::string cond;
+			int remainder;
+			std::string value;
+			std::string _operator;
+		};
+		std::vector<RestItems> restItems;
+		std::string condition;
+		int priority;
+	};
 	struct GatewaySwimmingLaneRouteJson {
 		std::string gatewayUniqueId;
 		long long;
@@ -42,40 +58,10 @@ public:
 		std::vector<ConditionsItem> conditions;
 		long gatewayId;
 	};
-	struct EntryRules {
-		struct RestItems {
-			std::string datum;
-			int divisor;
-			int rate;
-			std::string name;
-			std::string type;
-			std::string cond;
-			int remainder;
-			std::string value;
-			std::string _operator;
-		};
-		std::vector<RestItems> restItems;
-		std::string path;
-		std::string condition;
-		bool enable;
-		int priority;
-	};
 	CreateOrUpdateSwimmingLaneRequest();
 	~CreateOrUpdateSwimmingLaneRequest();
 	std::string getMseSessionId() const;
 	void setMseSessionId(const std::string &mseSessionId);
-	std::string getSource() const;
-	void setSource(const std::string &source);
-	std::string getGmtModified() const;
-	void setGmtModified(const std::string &gmtModified);
-	std::string getUserId() const;
-	void setUserId(const std::string &userId);
-	std::string getLicenseKey() const;
-	void setLicenseKey(const std::string &licenseKey);
-	GatewaySwimmingLaneRouteJson getGatewaySwimmingLaneRouteJson() const;
-	void setGatewaySwimmingLaneRouteJson(const GatewaySwimmingLaneRouteJson &gatewaySwimmingLaneRouteJson);
-	std::string getRegionId() const;
-	void setRegionId(const std::string &regionId);
 	std::string getEntryRule() const;
 	void setEntryRule(const std::string &entryRule);
 	bool getEnable() const;
@@ -88,36 +74,33 @@ public:
 	void setEntryRules(const std::vector<EntryRules> &entryRules);
 	long getGroupId() const;
 	void setGroupId(long groupId);
-	std::string getGmtCreate() const;
-	void setGmtCreate(const std::string &gmtCreate);
 	bool getEnableRules() const;
 	void setEnableRules(bool enableRules);
 	std::string getName() const;
 	void setName(const std::string &name);
+	GatewaySwimmingLaneRouteJson getGatewaySwimmingLaneRouteJson() const;
+	void setGatewaySwimmingLaneRouteJson(const GatewaySwimmingLaneRouteJson &gatewaySwimmingLaneRouteJson);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
-	int getStatus() const;
-	void setStatus(int status);
 
 private:
 	std::string mseSessionId_;
-	std::string source_;
-	std::string gmtModified_;
-	std::string userId_;
-	std::string licenseKey_;
-	GatewaySwimmingLaneRouteJson gatewaySwimmingLaneRouteJson_;
-	std::string regionId_;
 	std::string entryRule_;
 	bool enable_;
 	long id_;
 	std::string tag_;
 	std::vector<EntryRules> entryRules_;
 	long groupId_;
-	std::string gmtCreate_;
 	bool enableRules_;
 	std::string name_;
+	GatewaySwimmingLaneRouteJson gatewaySwimmingLaneRouteJson_;
+	std::string regionId_;
+	std::string _namespace_;
 	std::string acceptLanguage_;
-	int status_;
 };
 } // namespace Model
 } // namespace Mse

mse/include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneResult.h

@@ -32,15 +32,63 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_MSE_EXPORT CreateOrUpdateSwimmingLaneResult : public ServiceResult
 			{
 			public:
+				struct Data
+				{
+					struct EntryRule
+					{
+						struct RestItemsItem
+						{
+							std::string type;
+							std::string cond;
+							std::vector<std::string> nameList;
+							std::string datum;
+							int rate;
+							std::string value;
+							std::string _operator;
+							int divisor;
+							std::string name;
+							int remainder;
+						};
+						std::string path;
+						std::string condition;
+						std::vector<EntryRule::RestItemsItem> restItems;
+						std::vector<std::string> paths;
+					};
+					int status;
+					std::vector<EntryRule> entryRules;
+					std::string gmtModified;
+					std::string gatewaySwimmingLaneRouteJson;
+					std::string name;
+					long groupId;
+					std::string entryRule;
+					std::string gmtCreate;
+					bool enable;
+					long id;
+					std::string tag;
+					std::string regionId;
+					bool enableRules;
+				};
 
 
 				CreateOrUpdateSwimmingLaneResult();
 				explicit CreateOrUpdateSwimmingLaneResult(const std::string &payload);
 				~CreateOrUpdateSwimmingLaneResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Data getData()const;
+				std::string getErrorCode()const;
+				int getCode()const;
+				bool getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string message_;
+				int httpStatusCode_;
+				Data data_;
+				std::string errorCode_;
+				int code_;
+				bool success_;
 
 			};
 		}

mse/include/alibabacloud/mse/model/CreateZnodeRequest.h

@@ -34,18 +34,18 @@ public:
 	void setMseSessionId(const std::string &mseSessionId);
 	std::string getData() const;
 	void setData(const std::string &data);
-	std::string getClusterId() const;
-	void setClusterId(const std::string &clusterId);
 	std::string getPath() const;
 	void setPath(const std::string &path);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
 
 private:
 	std::string mseSessionId_;
 	std::string data_;
-	std::string clusterId_;
 	std::string path_;
+	std::string clusterId_;
 	std::string acceptLanguage_;
 };
 } // namespace Model

mse/include/alibabacloud/mse/model/DeleteAuthResourceRequest.h

@@ -34,16 +34,16 @@ public:
 	void setMseSessionId(const std::string &mseSessionId);
 	std::string getGatewayUniqueId() const;
 	void setGatewayUniqueId(const std::string &gatewayUniqueId);
-	std::string getAcceptLanguage() const;
-	void setAcceptLanguage(const std::string &acceptLanguage);
 	long getId() const;
 	void setId(long id);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
 
 private:
 	std::string mseSessionId_;
 	std::string gatewayUniqueId_;
-	std::string acceptLanguage_;
 	long id_;
+	std::string acceptLanguage_;
 };
 } // namespace Model
 } // namespace Mse

mse/include/alibabacloud/mse/model/DeleteCircuitBreakerRulesRequest.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_MSE_MODEL_DELETECIRCUITBREAKERRULESREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETECIRCUITBREAKERRULESREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT DeleteCircuitBreakerRulesRequest : public RpcServiceRequest {
+public:
+	DeleteCircuitBreakerRulesRequest();
+	~DeleteCircuitBreakerRulesRequest();
+	std::string getMseSessionId() const;
+	void setMseSessionId(const std::string &mseSessionId);
+	std::string getAppName() const;
+	void setAppName(const std::string &appName);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::vector<long> getIds() const;
+	void setIds(const std::vector<long> &ids);
+
+private:
+	std::string mseSessionId_;
+	std::string appName_;
+	std::string _namespace_;
+	std::string acceptLanguage_;
+	std::vector<long> ids_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETECIRCUITBREAKERRULESREQUEST_H_

mse/include/alibabacloud/mse/model/DeleteCircuitBreakerRulesResult.h

@@ -0,0 +1,59 @@
+/*
+ * 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_MSE_MODEL_DELETECIRCUITBREAKERRULESRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETECIRCUITBREAKERRULESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT DeleteCircuitBreakerRulesResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteCircuitBreakerRulesResult();
+				explicit DeleteCircuitBreakerRulesResult(const std::string &payload);
+				~DeleteCircuitBreakerRulesResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::vector<std::string> getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::vector<std::string> data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETECIRCUITBREAKERRULESRESULT_H_

mse/include/alibabacloud/mse/model/DeleteEngineNamespaceRequest.h

@@ -32,21 +32,21 @@ public:
 	~DeleteEngineNamespaceRequest();
 	std::string getMseSessionId() const;
 	void setMseSessionId(const std::string &mseSessionId);
+	std::string getId() const;
+	void setId(const std::string &id);
 	std::string getClusterId() const;
 	void setClusterId(const std::string &clusterId);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
-	std::string getId() const;
-	void setId(const std::string &id);
 
 private:
 	std::string mseSessionId_;
+	std::string id_;
 	std::string clusterId_;
 	std::string instanceId_;
 	std::string acceptLanguage_;
-	std::string id_;
 };
 } // namespace Model
 } // namespace Mse

mse/include/alibabacloud/mse/model/DeleteFlowRulesRequest.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_MSE_MODEL_DELETEFLOWRULESREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETEFLOWRULESREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT DeleteFlowRulesRequest : public RpcServiceRequest {
+public:
+	DeleteFlowRulesRequest();
+	~DeleteFlowRulesRequest();
+	std::string getMseSessionId() const;
+	void setMseSessionId(const std::string &mseSessionId);
+	std::string getAppName() const;
+	void setAppName(const std::string &appName);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::vector<long> getIds() const;
+	void setIds(const std::vector<long> &ids);
+
+private:
+	std::string mseSessionId_;
+	std::string appName_;
+	std::string _namespace_;
+	std::string acceptLanguage_;
+	std::vector<long> ids_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETEFLOWRULESREQUEST_H_

mse/include/alibabacloud/mse/model/DeleteFlowRulesResult.h

@@ -0,0 +1,59 @@
+/*
+ * 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_MSE_MODEL_DELETEFLOWRULESRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETEFLOWRULESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT DeleteFlowRulesResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteFlowRulesResult();
+				explicit DeleteFlowRulesResult(const std::string &payload);
+				~DeleteFlowRulesResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::vector<std::string> getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::vector<std::string> data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETEFLOWRULESRESULT_H_

mse/include/alibabacloud/mse/model/DeleteGatewayAuthConsumerRequest.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_MSE_MODEL_DELETEGATEWAYAUTHCONSUMERREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYAUTHCONSUMERREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT DeleteGatewayAuthConsumerRequest : public RpcServiceRequest {
+public:
+	DeleteGatewayAuthConsumerRequest();
+	~DeleteGatewayAuthConsumerRequest();
+	std::string getMseSessionId() const;
+	void setMseSessionId(const std::string &mseSessionId);
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	long getId() const;
+	void setId(long id);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::string mseSessionId_;
+	std::string gatewayUniqueId_;
+	long id_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYAUTHCONSUMERREQUEST_H_

mse/include/alibabacloud/mse/model/DeleteGatewayAuthConsumerResourceRequest.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_MSE_MODEL_DELETEGATEWAYAUTHCONSUMERRESOURCEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYAUTHCONSUMERRESOURCEREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT DeleteGatewayAuthConsumerResourceRequest : public RpcServiceRequest {
+public:
+	DeleteGatewayAuthConsumerResourceRequest();
+	~DeleteGatewayAuthConsumerResourceRequest();
+	std::string getMseSessionId() const;
+	void setMseSessionId(const std::string &mseSessionId);
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	long getConsumerId() const;
+	void setConsumerId(long consumerId);
+	std::string getIdList() const;
+	void setIdList(const std::string &idList);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::string mseSessionId_;
+	std::string gatewayUniqueId_;
+	long consumerId_;
+	std::string idList_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYAUTHCONSUMERRESOURCEREQUEST_H_

mse/include/alibabacloud/mse/model/DeleteGatewayAuthConsumerResourceResult.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_MSE_MODEL_DELETEGATEWAYAUTHCONSUMERRESOURCERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYAUTHCONSUMERRESOURCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT DeleteGatewayAuthConsumerResourceResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteGatewayAuthConsumerResourceResult();
+				explicit DeleteGatewayAuthConsumerResourceResult(const std::string &payload);
+				~DeleteGatewayAuthConsumerResourceResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				bool getData()const;
+				std::string getErrorCode()const;
+				std::string getDynamicMessage()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				bool data_;
+				std::string errorCode_;
+				std::string dynamicMessage_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYAUTHCONSUMERRESOURCERESULT_H_