Add TimeOut.

VERSION

@@ -1 +1 @@
-1.36.1645
+1.36.1663

avatar/CMakeLists.txt

@@ -39,8 +39,14 @@ set(avatar_public_header_model
 	include/alibabacloud/avatar/model/QueryRunningInstanceResult.h
 	include/alibabacloud/avatar/model/QueryTimedResetOperateStatusRequest.h
 	include/alibabacloud/avatar/model/QueryTimedResetOperateStatusResult.h
+	include/alibabacloud/avatar/model/SendCommandRequest.h
+	include/alibabacloud/avatar/model/SendCommandResult.h
 	include/alibabacloud/avatar/model/SendMessageRequest.h
 	include/alibabacloud/avatar/model/SendMessageResult.h
+	include/alibabacloud/avatar/model/SendTextRequest.h
+	include/alibabacloud/avatar/model/SendTextResult.h
+	include/alibabacloud/avatar/model/SendVamlRequest.h
+	include/alibabacloud/avatar/model/SendVamlResult.h
 	include/alibabacloud/avatar/model/StartInstanceRequest.h
 	include/alibabacloud/avatar/model/StartInstanceResult.h
 	include/alibabacloud/avatar/model/StartTimedResetOperateRequest.h
@@ -76,8 +82,14 @@ set(avatar_src
 	src/model/QueryRunningInstanceResult.cc
 	src/model/QueryTimedResetOperateStatusRequest.cc
 	src/model/QueryTimedResetOperateStatusResult.cc
+	src/model/SendCommandRequest.cc
+	src/model/SendCommandResult.cc
 	src/model/SendMessageRequest.cc
 	src/model/SendMessageResult.cc
+	src/model/SendTextRequest.cc
+	src/model/SendTextResult.cc
+	src/model/SendVamlRequest.cc
+	src/model/SendVamlResult.cc
 	src/model/StartInstanceRequest.cc
 	src/model/StartInstanceResult.cc
 	src/model/StartTimedResetOperateRequest.cc

avatar/include/alibabacloud/avatar/AvatarClient.h

@@ -40,8 +40,14 @@
 #include "model/QueryRunningInstanceResult.h"
 #include "model/QueryTimedResetOperateStatusRequest.h"
 #include "model/QueryTimedResetOperateStatusResult.h"
+#include "model/SendCommandRequest.h"
+#include "model/SendCommandResult.h"
 #include "model/SendMessageRequest.h"
 #include "model/SendMessageResult.h"
+#include "model/SendTextRequest.h"
+#include "model/SendTextResult.h"
+#include "model/SendVamlRequest.h"
+#include "model/SendVamlResult.h"
 #include "model/StartInstanceRequest.h"
 #include "model/StartInstanceResult.h"
 #include "model/StartTimedResetOperateRequest.h"
@@ -92,9 +98,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::QueryTimedResetOperateStatusResult> QueryTimedResetOperateStatusOutcome;
 			typedef std::future<QueryTimedResetOperateStatusOutcome> QueryTimedResetOperateStatusOutcomeCallable;
 			typedef std::function<void(const AvatarClient*, const Model::QueryTimedResetOperateStatusRequest&, const QueryTimedResetOperateStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryTimedResetOperateStatusAsyncHandler;
+			typedef Outcome<Error, Model::SendCommandResult> SendCommandOutcome;
+			typedef std::future<SendCommandOutcome> SendCommandOutcomeCallable;
+			typedef std::function<void(const AvatarClient*, const Model::SendCommandRequest&, const SendCommandOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SendCommandAsyncHandler;
 			typedef Outcome<Error, Model::SendMessageResult> SendMessageOutcome;
 			typedef std::future<SendMessageOutcome> SendMessageOutcomeCallable;
 			typedef std::function<void(const AvatarClient*, const Model::SendMessageRequest&, const SendMessageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SendMessageAsyncHandler;
+			typedef Outcome<Error, Model::SendTextResult> SendTextOutcome;
+			typedef std::future<SendTextOutcome> SendTextOutcomeCallable;
+			typedef std::function<void(const AvatarClient*, const Model::SendTextRequest&, const SendTextOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SendTextAsyncHandler;
+			typedef Outcome<Error, Model::SendVamlResult> SendVamlOutcome;
+			typedef std::future<SendVamlOutcome> SendVamlOutcomeCallable;
+			typedef std::function<void(const AvatarClient*, const Model::SendVamlRequest&, const SendVamlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SendVamlAsyncHandler;
 			typedef Outcome<Error, Model::StartInstanceResult> StartInstanceOutcome;
 			typedef std::future<StartInstanceOutcome> StartInstanceOutcomeCallable;
 			typedef std::function<void(const AvatarClient*, const Model::StartInstanceRequest&, const StartInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartInstanceAsyncHandler;
@@ -148,9 +163,18 @@ namespace AlibabaCloud
 			QueryTimedResetOperateStatusOutcome queryTimedResetOperateStatus(const Model::QueryTimedResetOperateStatusRequest &request)const;
 			void queryTimedResetOperateStatusAsync(const Model::QueryTimedResetOperateStatusRequest& request, const QueryTimedResetOperateStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryTimedResetOperateStatusOutcomeCallable queryTimedResetOperateStatusCallable(const Model::QueryTimedResetOperateStatusRequest& request) const;
+			SendCommandOutcome sendCommand(const Model::SendCommandRequest &request)const;
+			void sendCommandAsync(const Model::SendCommandRequest& request, const SendCommandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SendCommandOutcomeCallable sendCommandCallable(const Model::SendCommandRequest& request) const;
 			SendMessageOutcome sendMessage(const Model::SendMessageRequest &request)const;
 			void sendMessageAsync(const Model::SendMessageRequest& request, const SendMessageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SendMessageOutcomeCallable sendMessageCallable(const Model::SendMessageRequest& request) const;
+			SendTextOutcome sendText(const Model::SendTextRequest &request)const;
+			void sendTextAsync(const Model::SendTextRequest& request, const SendTextAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SendTextOutcomeCallable sendTextCallable(const Model::SendTextRequest& request) const;
+			SendVamlOutcome sendVaml(const Model::SendVamlRequest &request)const;
+			void sendVamlAsync(const Model::SendVamlRequest& request, const SendVamlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SendVamlOutcomeCallable sendVamlCallable(const Model::SendVamlRequest& request) const;
 			StartInstanceOutcome startInstance(const Model::StartInstanceRequest &request)const;
 			void startInstanceAsync(const Model::StartInstanceRequest& request, const StartInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StartInstanceOutcomeCallable startInstanceCallable(const Model::StartInstanceRequest& request) const;

avatar/include/alibabacloud/avatar/model/SendCommandRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_AVATAR_MODEL_SENDCOMMANDREQUEST_H_
+#define ALIBABACLOUD_AVATAR_MODEL_SENDCOMMANDREQUEST_H_
+
+#include <alibabacloud/avatar/AvatarExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Avatar {
+namespace Model {
+class ALIBABACLOUD_AVATAR_EXPORT SendCommandRequest : public RpcServiceRequest {
+public:
+	SendCommandRequest();
+	~SendCommandRequest();
+	bool getFeedback() const;
+	void setFeedback(bool feedback);
+	std::string getCode() const;
+	void setCode(const std::string &code);
+	std::string getUniqueCode() const;
+	void setUniqueCode(const std::string &uniqueCode);
+	long getTenantId() const;
+	void setTenantId(long tenantId);
+	std::string getSessionId() const;
+	void setSessionId(const std::string &sessionId);
+	std::map<std::string, std::string> getContent() const;
+	void setContent(const std::map<std::string, std::string> &content);
+
+private:
+	bool feedback_;
+	std::string code_;
+	std::string uniqueCode_;
+	long tenantId_;
+	std::string sessionId_;
+	std::map<std::string, std::string> content_;
+};
+} // namespace Model
+} // namespace Avatar
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AVATAR_MODEL_SENDCOMMANDREQUEST_H_

avatar/include/alibabacloud/avatar/model/SendCommandResult.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_AVATAR_MODEL_SENDCOMMANDRESULT_H_
+#define ALIBABACLOUD_AVATAR_MODEL_SENDCOMMANDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/avatar/AvatarExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Avatar
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_AVATAR_EXPORT SendCommandResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string uniqueCode;
+					std::string sessionId;
+				};
+
+
+				SendCommandResult();
+				explicit SendCommandResult(const std::string &payload);
+				~SendCommandResult();
+				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_AVATAR_MODEL_SENDCOMMANDRESULT_H_

avatar/include/alibabacloud/avatar/model/SendTextRequest.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_AVATAR_MODEL_SENDTEXTREQUEST_H_
+#define ALIBABACLOUD_AVATAR_MODEL_SENDTEXTREQUEST_H_
+
+#include <alibabacloud/avatar/AvatarExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Avatar {
+namespace Model {
+class ALIBABACLOUD_AVATAR_EXPORT SendTextRequest : public RpcServiceRequest {
+public:
+	struct StreamExtension {
+		bool isStream;
+		int index;
+		std::string position;
+	};
+	SendTextRequest();
+	~SendTextRequest();
+	bool getFeedback() const;
+	void setFeedback(bool feedback);
+	std::string getUniqueCode() const;
+	void setUniqueCode(const std::string &uniqueCode);
+	StreamExtension getStreamExtension() const;
+	void setStreamExtension(const StreamExtension &streamExtension);
+	long getTenantId() const;
+	void setTenantId(long tenantId);
+	bool getInterrupt() const;
+	void setInterrupt(bool interrupt);
+	std::string getSessionId() const;
+	void setSessionId(const std::string &sessionId);
+	std::string getText() const;
+	void setText(const std::string &text);
+
+private:
+	bool feedback_;
+	std::string uniqueCode_;
+	StreamExtension streamExtension_;
+	long tenantId_;
+	bool interrupt_;
+	std::string sessionId_;
+	std::string text_;
+};
+} // namespace Model
+} // namespace Avatar
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AVATAR_MODEL_SENDTEXTREQUEST_H_

avatar/include/alibabacloud/avatar/model/SendTextResult.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_AVATAR_MODEL_SENDTEXTRESULT_H_
+#define ALIBABACLOUD_AVATAR_MODEL_SENDTEXTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/avatar/AvatarExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Avatar
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_AVATAR_EXPORT SendTextResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string uniqueCode;
+					std::string sessionId;
+				};
+
+
+				SendTextResult();
+				explicit SendTextResult(const std::string &payload);
+				~SendTextResult();
+				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_AVATAR_MODEL_SENDTEXTRESULT_H_

avatar/include/alibabacloud/avatar/model/SendVamlRequest.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_AVATAR_MODEL_SENDVAMLREQUEST_H_
+#define ALIBABACLOUD_AVATAR_MODEL_SENDVAMLREQUEST_H_
+
+#include <alibabacloud/avatar/AvatarExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Avatar {
+namespace Model {
+class ALIBABACLOUD_AVATAR_EXPORT SendVamlRequest : public RpcServiceRequest {
+public:
+	SendVamlRequest();
+	~SendVamlRequest();
+	long getTenantId() const;
+	void setTenantId(long tenantId);
+	std::string getSessionId() const;
+	void setSessionId(const std::string &sessionId);
+	std::string getVaml() const;
+	void setVaml(const std::string &vaml);
+
+private:
+	long tenantId_;
+	std::string sessionId_;
+	std::string vaml_;
+};
+} // namespace Model
+} // namespace Avatar
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AVATAR_MODEL_SENDVAMLREQUEST_H_

avatar/include/alibabacloud/avatar/model/SendVamlResult.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_AVATAR_MODEL_SENDVAMLRESULT_H_
+#define ALIBABACLOUD_AVATAR_MODEL_SENDVAMLRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/avatar/AvatarExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Avatar
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_AVATAR_EXPORT SendVamlResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string uniqueCode;
+					std::string sessionId;
+				};
+
+
+				SendVamlResult();
+				explicit SendVamlResult(const std::string &payload);
+				~SendVamlResult();
+				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_AVATAR_MODEL_SENDVAMLRESULT_H_

avatar/src/AvatarClient.cc

@@ -375,6 +375,42 @@ AvatarClient::QueryTimedResetOperateStatusOutcomeCallable AvatarClient::queryTim
 	return task->get_future();
 }
 
+AvatarClient::SendCommandOutcome AvatarClient::sendCommand(const SendCommandRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SendCommandOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SendCommandOutcome(SendCommandResult(outcome.result()));
+	else
+		return SendCommandOutcome(outcome.error());
+}
+
+void AvatarClient::sendCommandAsync(const SendCommandRequest& request, const SendCommandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, sendCommand(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AvatarClient::SendCommandOutcomeCallable AvatarClient::sendCommandCallable(const SendCommandRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SendCommandOutcome()>>(
+			[this, request]()
+			{
+			return this->sendCommand(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AvatarClient::SendMessageOutcome AvatarClient::sendMessage(const SendMessageRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -411,6 +447,78 @@ AvatarClient::SendMessageOutcomeCallable AvatarClient::sendMessageCallable(const
 	return task->get_future();
 }
 
+AvatarClient::SendTextOutcome AvatarClient::sendText(const SendTextRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SendTextOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SendTextOutcome(SendTextResult(outcome.result()));
+	else
+		return SendTextOutcome(outcome.error());
+}
+
+void AvatarClient::sendTextAsync(const SendTextRequest& request, const SendTextAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, sendText(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AvatarClient::SendTextOutcomeCallable AvatarClient::sendTextCallable(const SendTextRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SendTextOutcome()>>(
+			[this, request]()
+			{
+			return this->sendText(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AvatarClient::SendVamlOutcome AvatarClient::sendVaml(const SendVamlRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SendVamlOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SendVamlOutcome(SendVamlResult(outcome.result()));
+	else
+		return SendVamlOutcome(outcome.error());
+}
+
+void AvatarClient::sendVamlAsync(const SendVamlRequest& request, const SendVamlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, sendVaml(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AvatarClient::SendVamlOutcomeCallable AvatarClient::sendVamlCallable(const SendVamlRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SendVamlOutcome()>>(
+			[this, request]()
+			{
+			return this->sendVaml(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AvatarClient::StartInstanceOutcome AvatarClient::startInstance(const StartInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

avatar/src/model/SendCommandRequest.cc

@@ -0,0 +1,83 @@
+/*
+ * 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/avatar/model/SendCommandRequest.h>
+
+using AlibabaCloud::Avatar::Model::SendCommandRequest;
+
+SendCommandRequest::SendCommandRequest()
+    : RpcServiceRequest("avatar", "2022-01-30", "SendCommand") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+SendCommandRequest::~SendCommandRequest() {}
+
+bool SendCommandRequest::getFeedback() const {
+  return feedback_;
+}
+
+void SendCommandRequest::setFeedback(bool feedback) {
+  feedback_ = feedback;
+  setParameter(std::string("Feedback"), feedback ? "true" : "false");
+}
+
+std::string SendCommandRequest::getCode() const {
+  return code_;
+}
+
+void SendCommandRequest::setCode(const std::string &code) {
+  code_ = code;
+  setParameter(std::string("Code"), code);
+}
+
+std::string SendCommandRequest::getUniqueCode() const {
+  return uniqueCode_;
+}
+
+void SendCommandRequest::setUniqueCode(const std::string &uniqueCode) {
+  uniqueCode_ = uniqueCode;
+  setParameter(std::string("UniqueCode"), uniqueCode);
+}
+
+long SendCommandRequest::getTenantId() const {
+  return tenantId_;
+}
+
+void SendCommandRequest::setTenantId(long tenantId) {
+  tenantId_ = tenantId;
+  setParameter(std::string("TenantId"), std::to_string(tenantId));
+}
+
+std::string SendCommandRequest::getSessionId() const {
+  return sessionId_;
+}
+
+void SendCommandRequest::setSessionId(const std::string &sessionId) {
+  sessionId_ = sessionId;
+  setParameter(std::string("SessionId"), sessionId);
+}
+
+std::map<std::string, std::string> SendCommandRequest::getContent() const {
+  return content_;
+}
+
+void SendCommandRequest::setContent(const std::map<std::string, std::string> &content) {
+  content_ = content;
+  for(auto const &iter1 : content) {
+    setParameter(std::string("Content") + "." + iter1.first, iter1.second);
+  }
+}
+

avatar/src/model/SendCommandResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/avatar/model/SendCommandResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Avatar;
+using namespace AlibabaCloud::Avatar::Model;
+
+SendCommandResult::SendCommandResult() :
+	ServiceResult()
+{}
+
+SendCommandResult::SendCommandResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SendCommandResult::~SendCommandResult()
+{}
+
+void SendCommandResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["SessionId"].isNull())
+		data_.sessionId = dataNode["SessionId"].asString();
+	if(!dataNode["UniqueCode"].isNull())
+		data_.uniqueCode = dataNode["UniqueCode"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string SendCommandResult::getMessage()const
+{
+	return message_;
+}
+
+SendCommandResult::Data SendCommandResult::getData()const
+{
+	return data_;
+}
+
+std::string SendCommandResult::getCode()const
+{
+	return code_;
+}
+
+bool SendCommandResult::getSuccess()const
+{
+	return success_;
+}
+

avatar/src/model/SendTextRequest.cc

@@ -0,0 +1,92 @@
+/*
+ * 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/avatar/model/SendTextRequest.h>
+
+using AlibabaCloud::Avatar::Model::SendTextRequest;
+
+SendTextRequest::SendTextRequest()
+    : RpcServiceRequest("avatar", "2022-01-30", "SendText") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+SendTextRequest::~SendTextRequest() {}
+
+bool SendTextRequest::getFeedback() const {
+  return feedback_;
+}
+
+void SendTextRequest::setFeedback(bool feedback) {
+  feedback_ = feedback;
+  setParameter(std::string("Feedback"), feedback ? "true" : "false");
+}
+
+std::string SendTextRequest::getUniqueCode() const {
+  return uniqueCode_;
+}
+
+void SendTextRequest::setUniqueCode(const std::string &uniqueCode) {
+  uniqueCode_ = uniqueCode;
+  setParameter(std::string("UniqueCode"), uniqueCode);
+}
+
+SendTextRequest::StreamExtension SendTextRequest::getStreamExtension() const {
+  return streamExtension_;
+}
+
+void SendTextRequest::setStreamExtension(const SendTextRequest::StreamExtension &streamExtension) {
+  streamExtension_ = streamExtension;
+  setParameter(std::string("StreamExtension") + ".IsStream", streamExtension.isStream ? "true" : "false");
+  setParameter(std::string("StreamExtension") + ".Index", std::to_string(streamExtension.index));
+  setParameter(std::string("StreamExtension") + ".Position", streamExtension.position);
+}
+
+long SendTextRequest::getTenantId() const {
+  return tenantId_;
+}
+
+void SendTextRequest::setTenantId(long tenantId) {
+  tenantId_ = tenantId;
+  setParameter(std::string("TenantId"), std::to_string(tenantId));
+}
+
+bool SendTextRequest::getInterrupt() const {
+  return interrupt_;
+}
+
+void SendTextRequest::setInterrupt(bool interrupt) {
+  interrupt_ = interrupt;
+  setParameter(std::string("Interrupt"), interrupt ? "true" : "false");
+}
+
+std::string SendTextRequest::getSessionId() const {
+  return sessionId_;
+}
+
+void SendTextRequest::setSessionId(const std::string &sessionId) {
+  sessionId_ = sessionId;
+  setParameter(std::string("SessionId"), sessionId);
+}
+
+std::string SendTextRequest::getText() const {
+  return text_;
+}
+
+void SendTextRequest::setText(const std::string &text) {
+  text_ = text;
+  setParameter(std::string("Text"), text);
+}
+

avatar/src/model/SendTextResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/avatar/model/SendTextResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Avatar;
+using namespace AlibabaCloud::Avatar::Model;
+
+SendTextResult::SendTextResult() :
+	ServiceResult()
+{}
+
+SendTextResult::SendTextResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SendTextResult::~SendTextResult()
+{}
+
+void SendTextResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["SessionId"].isNull())
+		data_.sessionId = dataNode["SessionId"].asString();
+	if(!dataNode["UniqueCode"].isNull())
+		data_.uniqueCode = dataNode["UniqueCode"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string SendTextResult::getMessage()const
+{
+	return message_;
+}
+
+SendTextResult::Data SendTextResult::getData()const
+{
+	return data_;
+}
+
+std::string SendTextResult::getCode()const
+{
+	return code_;
+}
+
+bool SendTextResult::getSuccess()const
+{
+	return success_;
+}
+

avatar/src/model/SendVamlRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/avatar/model/SendVamlRequest.h>
+
+using AlibabaCloud::Avatar::Model::SendVamlRequest;
+
+SendVamlRequest::SendVamlRequest()
+    : RpcServiceRequest("avatar", "2022-01-30", "SendVaml") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+SendVamlRequest::~SendVamlRequest() {}
+
+long SendVamlRequest::getTenantId() const {
+  return tenantId_;
+}
+
+void SendVamlRequest::setTenantId(long tenantId) {
+  tenantId_ = tenantId;
+  setParameter(std::string("TenantId"), std::to_string(tenantId));
+}
+
+std::string SendVamlRequest::getSessionId() const {
+  return sessionId_;
+}
+
+void SendVamlRequest::setSessionId(const std::string &sessionId) {
+  sessionId_ = sessionId;
+  setParameter(std::string("SessionId"), sessionId);
+}
+
+std::string SendVamlRequest::getVaml() const {
+  return vaml_;
+}
+
+void SendVamlRequest::setVaml(const std::string &vaml) {
+  vaml_ = vaml;
+  setParameter(std::string("Vaml"), vaml);
+}
+

avatar/src/model/SendVamlResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/avatar/model/SendVamlResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Avatar;
+using namespace AlibabaCloud::Avatar::Model;
+
+SendVamlResult::SendVamlResult() :
+	ServiceResult()
+{}
+
+SendVamlResult::SendVamlResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SendVamlResult::~SendVamlResult()
+{}
+
+void SendVamlResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["SessionId"].isNull())
+		data_.sessionId = dataNode["SessionId"].asString();
+	if(!dataNode["UniqueCode"].isNull())
+		data_.uniqueCode = dataNode["UniqueCode"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string SendVamlResult::getMessage()const
+{
+	return message_;
+}
+
+SendVamlResult::Data SendVamlResult::getData()const
+{
+	return data_;
+}
+
+std::string SendVamlResult::getCode()const
+{
+	return code_;
+}
+
+bool SendVamlResult::getSuccess()const
+{
+	return success_;
+}
+

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())

dms-enterprise/CMakeLists.txt

@@ -45,6 +45,8 @@ set(dms-enterprise_public_header_model
 	include/alibabacloud/dms-enterprise/model/CloseOrderResult.h
 	include/alibabacloud/dms-enterprise/model/CreateAuthorityTemplateRequest.h
 	include/alibabacloud/dms-enterprise/model/CreateAuthorityTemplateResult.h
+	include/alibabacloud/dms-enterprise/model/CreateDataArchiveOrderRequest.h
+	include/alibabacloud/dms-enterprise/model/CreateDataArchiveOrderResult.h
 	include/alibabacloud/dms-enterprise/model/CreateDataCorrectOrderRequest.h
 	include/alibabacloud/dms-enterprise/model/CreateDataCorrectOrderResult.h
 	include/alibabacloud/dms-enterprise/model/CreateDataCronClearOrderRequest.h
@@ -137,6 +139,8 @@ set(dms-enterprise_public_header_model
 	include/alibabacloud/dms-enterprise/model/GetDBTaskSQLJobLogResult.h
 	include/alibabacloud/dms-enterprise/model/GetDBTopologyRequest.h
 	include/alibabacloud/dms-enterprise/model/GetDBTopologyResult.h
+	include/alibabacloud/dms-enterprise/model/GetDataArchiveCountRequest.h
+	include/alibabacloud/dms-enterprise/model/GetDataArchiveCountResult.h
 	include/alibabacloud/dms-enterprise/model/GetDataArchiveOrderDetailRequest.h
 	include/alibabacloud/dms-enterprise/model/GetDataArchiveOrderDetailResult.h
 	include/alibabacloud/dms-enterprise/model/GetDataCorrectBackupFilesRequest.h
@@ -460,6 +464,8 @@ set(dms-enterprise_src
 	src/model/CloseOrderResult.cc
 	src/model/CreateAuthorityTemplateRequest.cc
 	src/model/CreateAuthorityTemplateResult.cc
+	src/model/CreateDataArchiveOrderRequest.cc
+	src/model/CreateDataArchiveOrderResult.cc
 	src/model/CreateDataCorrectOrderRequest.cc
 	src/model/CreateDataCorrectOrderResult.cc
 	src/model/CreateDataCronClearOrderRequest.cc
@@ -552,6 +558,8 @@ set(dms-enterprise_src
 	src/model/GetDBTaskSQLJobLogResult.cc
 	src/model/GetDBTopologyRequest.cc
 	src/model/GetDBTopologyResult.cc
+	src/model/GetDataArchiveCountRequest.cc
+	src/model/GetDataArchiveCountResult.cc
 	src/model/GetDataArchiveOrderDetailRequest.cc
 	src/model/GetDataArchiveOrderDetailResult.cc
 	src/model/GetDataCorrectBackupFilesRequest.cc

dms-enterprise/include/alibabacloud/dms-enterprise/Dms_enterpriseClient.h

@@ -46,6 +46,8 @@
 #include "model/CloseOrderResult.h"
 #include "model/CreateAuthorityTemplateRequest.h"
 #include "model/CreateAuthorityTemplateResult.h"
+#include "model/CreateDataArchiveOrderRequest.h"
+#include "model/CreateDataArchiveOrderResult.h"
 #include "model/CreateDataCorrectOrderRequest.h"
 #include "model/CreateDataCorrectOrderResult.h"
 #include "model/CreateDataCronClearOrderRequest.h"
@@ -138,6 +140,8 @@
 #include "model/GetDBTaskSQLJobLogResult.h"
 #include "model/GetDBTopologyRequest.h"
 #include "model/GetDBTopologyResult.h"
+#include "model/GetDataArchiveCountRequest.h"
+#include "model/GetDataArchiveCountResult.h"
 #include "model/GetDataArchiveOrderDetailRequest.h"
 #include "model/GetDataArchiveOrderDetailResult.h"
 #include "model/GetDataCorrectBackupFilesRequest.h"
@@ -479,6 +483,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateAuthorityTemplateResult> CreateAuthorityTemplateOutcome;
 			typedef std::future<CreateAuthorityTemplateOutcome> CreateAuthorityTemplateOutcomeCallable;
 			typedef std::function<void(const Dms_enterpriseClient*, const Model::CreateAuthorityTemplateRequest&, const CreateAuthorityTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAuthorityTemplateAsyncHandler;
+			typedef Outcome<Error, Model::CreateDataArchiveOrderResult> CreateDataArchiveOrderOutcome;
+			typedef std::future<CreateDataArchiveOrderOutcome> CreateDataArchiveOrderOutcomeCallable;
+			typedef std::function<void(const Dms_enterpriseClient*, const Model::CreateDataArchiveOrderRequest&, const CreateDataArchiveOrderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDataArchiveOrderAsyncHandler;
 			typedef Outcome<Error, Model::CreateDataCorrectOrderResult> CreateDataCorrectOrderOutcome;
 			typedef std::future<CreateDataCorrectOrderOutcome> CreateDataCorrectOrderOutcomeCallable;
 			typedef std::function<void(const Dms_enterpriseClient*, const Model::CreateDataCorrectOrderRequest&, const CreateDataCorrectOrderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDataCorrectOrderAsyncHandler;
@@ -617,6 +624,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetDBTopologyResult> GetDBTopologyOutcome;
 			typedef std::future<GetDBTopologyOutcome> GetDBTopologyOutcomeCallable;
 			typedef std::function<void(const Dms_enterpriseClient*, const Model::GetDBTopologyRequest&, const GetDBTopologyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDBTopologyAsyncHandler;
+			typedef Outcome<Error, Model::GetDataArchiveCountResult> GetDataArchiveCountOutcome;
+			typedef std::future<GetDataArchiveCountOutcome> GetDataArchiveCountOutcomeCallable;
+			typedef std::function<void(const Dms_enterpriseClient*, const Model::GetDataArchiveCountRequest&, const GetDataArchiveCountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDataArchiveCountAsyncHandler;
 			typedef Outcome<Error, Model::GetDataArchiveOrderDetailResult> GetDataArchiveOrderDetailOutcome;
 			typedef std::future<GetDataArchiveOrderDetailOutcome> GetDataArchiveOrderDetailOutcomeCallable;
 			typedef std::function<void(const Dms_enterpriseClient*, const Model::GetDataArchiveOrderDetailRequest&, const GetDataArchiveOrderDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDataArchiveOrderDetailAsyncHandler;
@@ -1102,6 +1112,9 @@ namespace AlibabaCloud
 			CreateAuthorityTemplateOutcome createAuthorityTemplate(const Model::CreateAuthorityTemplateRequest &request)const;
 			void createAuthorityTemplateAsync(const Model::CreateAuthorityTemplateRequest& request, const CreateAuthorityTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateAuthorityTemplateOutcomeCallable createAuthorityTemplateCallable(const Model::CreateAuthorityTemplateRequest& request) const;
+			CreateDataArchiveOrderOutcome createDataArchiveOrder(const Model::CreateDataArchiveOrderRequest &request)const;
+			void createDataArchiveOrderAsync(const Model::CreateDataArchiveOrderRequest& request, const CreateDataArchiveOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDataArchiveOrderOutcomeCallable createDataArchiveOrderCallable(const Model::CreateDataArchiveOrderRequest& request) const;
 			CreateDataCorrectOrderOutcome createDataCorrectOrder(const Model::CreateDataCorrectOrderRequest &request)const;
 			void createDataCorrectOrderAsync(const Model::CreateDataCorrectOrderRequest& request, const CreateDataCorrectOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDataCorrectOrderOutcomeCallable createDataCorrectOrderCallable(const Model::CreateDataCorrectOrderRequest& request) const;
@@ -1240,6 +1253,9 @@ namespace AlibabaCloud
 			GetDBTopologyOutcome getDBTopology(const Model::GetDBTopologyRequest &request)const;
 			void getDBTopologyAsync(const Model::GetDBTopologyRequest& request, const GetDBTopologyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetDBTopologyOutcomeCallable getDBTopologyCallable(const Model::GetDBTopologyRequest& request) const;
+			GetDataArchiveCountOutcome getDataArchiveCount(const Model::GetDataArchiveCountRequest &request)const;
+			void getDataArchiveCountAsync(const Model::GetDataArchiveCountRequest& request, const GetDataArchiveCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDataArchiveCountOutcomeCallable getDataArchiveCountCallable(const Model::GetDataArchiveCountRequest& request) const;
 			GetDataArchiveOrderDetailOutcome getDataArchiveOrderDetail(const Model::GetDataArchiveOrderDetailRequest &request)const;
 			void getDataArchiveOrderDetailAsync(const Model::GetDataArchiveOrderDetailRequest& request, const GetDataArchiveOrderDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetDataArchiveOrderDetailOutcomeCallable getDataArchiveOrderDetailCallable(const Model::GetDataArchiveOrderDetailRequest& request) const;

dms-enterprise/include/alibabacloud/dms-enterprise/model/CreateDataArchiveOrderRequest.h

@@ -0,0 +1,77 @@
+/*
+ * 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_DMS_ENTERPRISE_MODEL_CREATEDATAARCHIVEORDERREQUEST_H_
+#define ALIBABACLOUD_DMS_ENTERPRISE_MODEL_CREATEDATAARCHIVEORDERREQUEST_H_
+
+#include <alibabacloud/dms-enterprise/Dms_enterpriseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Dms_enterprise {
+namespace Model {
+class ALIBABACLOUD_DMS_ENTERPRISE_EXPORT CreateDataArchiveOrderRequest : public RpcServiceRequest {
+public:
+	struct Param {
+		std::string string;
+		std::vector<std::string> variables;
+		std::string targetInstanceId;
+		std::string string;
+		std::vector<std::string> tableMapping;
+		std::string string;
+		std::vector<std::string> orderAfter;
+		long sourceDatabaseId;
+		std::string dbSchema;
+		std::string runMethod;
+		bool logic;
+		std::string archiveMethod;
+		struct TableIncludesItem {
+			std::string tableWhere;
+			std::string tableName;
+		};
+		TableIncludesItem tableIncludesItem;
+		std::vector<TableIncludesItem> tableIncludes;
+	};
+	CreateDataArchiveOrderRequest();
+	~CreateDataArchiveOrderRequest();
+	long getTid() const;
+	void setTid(long tid);
+	long getParentId() const;
+	void setParentId(long parentId);
+	std::string getPluginType() const;
+	void setPluginType(const std::string &pluginType);
+	Param getParam() const;
+	void setParam(const Param &param);
+	std::vector<std::string> getRelatedUserList() const;
+	void setRelatedUserList(const std::vector<std::string> &relatedUserList);
+	std::string getComment() const;
+	void setComment(const std::string &comment);
+
+private:
+	long tid_;
+	long parentId_;
+	std::string pluginType_;
+	Param param_;
+	std::vector<std::string> relatedUserList_;
+	std::string comment_;
+};
+} // namespace Model
+} // namespace Dms_enterprise
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_DMS_ENTERPRISE_MODEL_CREATEDATAARCHIVEORDERREQUEST_H_

dms-enterprise/include/alibabacloud/dms-enterprise/model/CreateDataArchiveOrderResult.h

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

dms-enterprise/include/alibabacloud/dms-enterprise/model/GetDataArchiveCountRequest.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_DMS_ENTERPRISE_MODEL_GETDATAARCHIVECOUNTREQUEST_H_
+#define ALIBABACLOUD_DMS_ENTERPRISE_MODEL_GETDATAARCHIVECOUNTREQUEST_H_
+
+#include <alibabacloud/dms-enterprise/Dms_enterpriseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Dms_enterprise {
+namespace Model {
+class ALIBABACLOUD_DMS_ENTERPRISE_EXPORT GetDataArchiveCountRequest : public RpcServiceRequest {
+public:
+	GetDataArchiveCountRequest();
+	~GetDataArchiveCountRequest();
+	std::string getSearchDateType() const;
+	void setSearchDateType(const std::string &searchDateType);
+	long getTid() const;
+	void setTid(long tid);
+	std::string getPluginType() const;
+	void setPluginType(const std::string &pluginType);
+	std::string getOrderResultType() const;
+	void setOrderResultType(const std::string &orderResultType);
+
+private:
+	std::string searchDateType_;
+	long tid_;
+	std::string pluginType_;
+	std::string orderResultType_;
+};
+} // namespace Model
+} // namespace Dms_enterprise
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_DMS_ENTERPRISE_MODEL_GETDATAARCHIVECOUNTREQUEST_H_

dms-enterprise/include/alibabacloud/dms-enterprise/model/GetDataArchiveCountResult.h

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

dms-enterprise/src/Dms-enterpriseClient.cc

@@ -483,6 +483,42 @@ Dms_enterpriseClient::CreateAuthorityTemplateOutcomeCallable Dms_enterpriseClien
 	return task->get_future();
 }
 
+Dms_enterpriseClient::CreateDataArchiveOrderOutcome Dms_enterpriseClient::createDataArchiveOrder(const CreateDataArchiveOrderRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDataArchiveOrderOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDataArchiveOrderOutcome(CreateDataArchiveOrderResult(outcome.result()));
+	else
+		return CreateDataArchiveOrderOutcome(outcome.error());
+}
+
+void Dms_enterpriseClient::createDataArchiveOrderAsync(const CreateDataArchiveOrderRequest& request, const CreateDataArchiveOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDataArchiveOrder(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dms_enterpriseClient::CreateDataArchiveOrderOutcomeCallable Dms_enterpriseClient::createDataArchiveOrderCallable(const CreateDataArchiveOrderRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDataArchiveOrderOutcome()>>(
+			[this, request]()
+			{
+			return this->createDataArchiveOrder(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dms_enterpriseClient::CreateDataCorrectOrderOutcome Dms_enterpriseClient::createDataCorrectOrder(const CreateDataCorrectOrderRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2139,6 +2175,42 @@ Dms_enterpriseClient::GetDBTopologyOutcomeCallable Dms_enterpriseClient::getDBTo
 	return task->get_future();
 }
 
+Dms_enterpriseClient::GetDataArchiveCountOutcome Dms_enterpriseClient::getDataArchiveCount(const GetDataArchiveCountRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetDataArchiveCountOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetDataArchiveCountOutcome(GetDataArchiveCountResult(outcome.result()));
+	else
+		return GetDataArchiveCountOutcome(outcome.error());
+}
+
+void Dms_enterpriseClient::getDataArchiveCountAsync(const GetDataArchiveCountRequest& request, const GetDataArchiveCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getDataArchiveCount(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dms_enterpriseClient::GetDataArchiveCountOutcomeCallable Dms_enterpriseClient::getDataArchiveCountCallable(const GetDataArchiveCountRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetDataArchiveCountOutcome()>>(
+			[this, request]()
+			{
+			return this->getDataArchiveCount(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dms_enterpriseClient::GetDataArchiveOrderDetailOutcome Dms_enterpriseClient::getDataArchiveOrderDetail(const GetDataArchiveOrderDetailRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

dms-enterprise/src/model/CreateDataArchiveOrderRequest.cc

@@ -0,0 +1,101 @@
+/*
+ * 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/dms-enterprise/model/CreateDataArchiveOrderRequest.h>
+
+using AlibabaCloud::Dms_enterprise::Model::CreateDataArchiveOrderRequest;
+
+CreateDataArchiveOrderRequest::CreateDataArchiveOrderRequest()
+    : RpcServiceRequest("dms-enterprise", "2018-11-01", "CreateDataArchiveOrder") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateDataArchiveOrderRequest::~CreateDataArchiveOrderRequest() {}
+
+long CreateDataArchiveOrderRequest::getTid() const {
+  return tid_;
+}
+
+void CreateDataArchiveOrderRequest::setTid(long tid) {
+  tid_ = tid;
+  setParameter(std::string("Tid"), std::to_string(tid));
+}
+
+long CreateDataArchiveOrderRequest::getParentId() const {
+  return parentId_;
+}
+
+void CreateDataArchiveOrderRequest::setParentId(long parentId) {
+  parentId_ = parentId;
+  setParameter(std::string("ParentId"), std::to_string(parentId));
+}
+
+std::string CreateDataArchiveOrderRequest::getPluginType() const {
+  return pluginType_;
+}
+
+void CreateDataArchiveOrderRequest::setPluginType(const std::string &pluginType) {
+  pluginType_ = pluginType;
+  setParameter(std::string("PluginType"), pluginType);
+}
+
+CreateDataArchiveOrderRequest::Param CreateDataArchiveOrderRequest::getParam() const {
+  return param_;
+}
+
+void CreateDataArchiveOrderRequest::setParam(const CreateDataArchiveOrderRequest::Param &param) {
+  param_ = param;
+  for(int dep1 = 0; dep1 != param.variables.size(); dep1++) {
+    setParameter(std::string("Param") + ".Variables." + std::to_string(dep1 + 1), param.variables[dep1]);
+  }
+  setParameter(std::string("Param") + ".TargetInstanceId", param.targetInstanceId);
+  for(int dep1 = 0; dep1 != param.tableMapping.size(); dep1++) {
+    setParameter(std::string("Param") + ".TableMapping." + std::to_string(dep1 + 1), param.tableMapping[dep1]);
+  }
+  for(int dep1 = 0; dep1 != param.orderAfter.size(); dep1++) {
+    setParameter(std::string("Param") + ".OrderAfter." + std::to_string(dep1 + 1), param.orderAfter[dep1]);
+  }
+  setParameter(std::string("Param") + ".SourceDatabaseId", std::to_string(param.sourceDatabaseId));
+  setParameter(std::string("Param") + ".DbSchema", param.dbSchema);
+  setParameter(std::string("Param") + ".RunMethod", param.runMethod);
+  setParameter(std::string("Param") + ".Logic", param.logic ? "true" : "false");
+  setParameter(std::string("Param") + ".ArchiveMethod", param.archiveMethod);
+  for(int dep1 = 0; dep1 != param.tableIncludes.size(); dep1++) {
+    setParameter(std::string("Param") + ".TableIncludes." + std::to_string(dep1 + 1) + ".TableWhere", param.tableIncludes[dep1].tableWhere);
+    setParameter(std::string("Param") + ".TableIncludes." + std::to_string(dep1 + 1) + ".TableName", param.tableIncludes[dep1].tableName);
+  }
+}
+
+std::vector<CreateDataArchiveOrderRequest::std::string> CreateDataArchiveOrderRequest::getRelatedUserList() const {
+  return relatedUserList_;
+}
+
+void CreateDataArchiveOrderRequest::setRelatedUserList(const std::vector<CreateDataArchiveOrderRequest::std::string> &relatedUserList) {
+  relatedUserList_ = relatedUserList;
+  for(int dep1 = 0; dep1 != relatedUserList.size(); dep1++) {
+    setParameter(std::string("RelatedUserList") + "." + std::to_string(dep1 + 1), relatedUserList[dep1]);
+  }
+}
+
+std::string CreateDataArchiveOrderRequest::getComment() const {
+  return comment_;
+}
+
+void CreateDataArchiveOrderRequest::setComment(const std::string &comment) {
+  comment_ = comment;
+  setParameter(std::string("Comment"), comment);
+}
+

dms-enterprise/src/model/CreateDataArchiveOrderResult.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dms-enterprise/model/CreateDataArchiveOrderResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dms_enterprise;
+using namespace AlibabaCloud::Dms_enterprise::Model;
+
+CreateDataArchiveOrderResult::CreateDataArchiveOrderResult() :
+	ServiceResult()
+{}
+
+CreateDataArchiveOrderResult::CreateDataArchiveOrderResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateDataArchiveOrderResult::~CreateDataArchiveOrderResult()
+{}
+
+void CreateDataArchiveOrderResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCreateOrderResult = value["CreateOrderResult"]["OrderIds"];
+	for (const auto &item : allCreateOrderResult)
+		createOrderResult_.push_back(item.asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+
+}
+
+std::vector<std::string> CreateDataArchiveOrderResult::getCreateOrderResult()const
+{
+	return createOrderResult_;
+}
+
+std::string CreateDataArchiveOrderResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string CreateDataArchiveOrderResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool CreateDataArchiveOrderResult::getSuccess()const
+{
+	return success_;
+}
+

dms-enterprise/src/model/GetDataArchiveCountRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dms-enterprise/model/GetDataArchiveCountRequest.h>
+
+using AlibabaCloud::Dms_enterprise::Model::GetDataArchiveCountRequest;
+
+GetDataArchiveCountRequest::GetDataArchiveCountRequest()
+    : RpcServiceRequest("dms-enterprise", "2018-11-01", "GetDataArchiveCount") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetDataArchiveCountRequest::~GetDataArchiveCountRequest() {}
+
+std::string GetDataArchiveCountRequest::getSearchDateType() const {
+  return searchDateType_;
+}
+
+void GetDataArchiveCountRequest::setSearchDateType(const std::string &searchDateType) {
+  searchDateType_ = searchDateType;
+  setParameter(std::string("SearchDateType"), searchDateType);
+}
+
+long GetDataArchiveCountRequest::getTid() const {
+  return tid_;
+}
+
+void GetDataArchiveCountRequest::setTid(long tid) {
+  tid_ = tid;
+  setParameter(std::string("Tid"), std::to_string(tid));
+}
+
+std::string GetDataArchiveCountRequest::getPluginType() const {
+  return pluginType_;
+}
+
+void GetDataArchiveCountRequest::setPluginType(const std::string &pluginType) {
+  pluginType_ = pluginType;
+  setParameter(std::string("PluginType"), pluginType);
+}
+
+std::string GetDataArchiveCountRequest::getOrderResultType() const {
+  return orderResultType_;
+}
+
+void GetDataArchiveCountRequest::setOrderResultType(const std::string &orderResultType) {
+  orderResultType_ = orderResultType;
+  setParameter(std::string("OrderResultType"), orderResultType);
+}
+

dms-enterprise/src/model/GetDataArchiveCountResult.cc

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

eais/CMakeLists.txt

@@ -23,6 +23,8 @@ set(eais_public_header
 set(eais_public_header_model 
 	include/alibabacloud/eais/model/AttachEaiRequest.h
 	include/alibabacloud/eais/model/AttachEaiResult.h
+	include/alibabacloud/eais/model/AttachEaisEiRequest.h
+	include/alibabacloud/eais/model/AttachEaisEiResult.h
 	include/alibabacloud/eais/model/ChangeResourceGroupRequest.h
 	include/alibabacloud/eais/model/ChangeResourceGroupResult.h
 	include/alibabacloud/eais/model/CreateEaiRequest.h
@@ -35,23 +37,35 @@ set(eais_public_header_model
 	include/alibabacloud/eais/model/CreateEaiEcsResult.h
 	include/alibabacloud/eais/model/CreateEaiJupyterRequest.h
 	include/alibabacloud/eais/model/CreateEaiJupyterResult.h
+	include/alibabacloud/eais/model/CreateEaisEiRequest.h
+	include/alibabacloud/eais/model/CreateEaisEiResult.h
 	include/alibabacloud/eais/model/DeleteEaiRequest.h
 	include/alibabacloud/eais/model/DeleteEaiResult.h
 	include/alibabacloud/eais/model/DeleteEaiAllRequest.h
 	include/alibabacloud/eais/model/DeleteEaiAllResult.h
+	include/alibabacloud/eais/model/DeleteEaisEiRequest.h
+	include/alibabacloud/eais/model/DeleteEaisEiResult.h
 	include/alibabacloud/eais/model/DescribeEaisRequest.h
 	include/alibabacloud/eais/model/DescribeEaisResult.h
 	include/alibabacloud/eais/model/DescribeRegionsRequest.h
 	include/alibabacloud/eais/model/DescribeRegionsResult.h
 	include/alibabacloud/eais/model/DetachEaiRequest.h
 	include/alibabacloud/eais/model/DetachEaiResult.h
+	include/alibabacloud/eais/model/DetachEaisEiRequest.h
+	include/alibabacloud/eais/model/DetachEaisEiResult.h
 	include/alibabacloud/eais/model/GetInstanceMetricsRequest.h
-	include/alibabacloud/eais/model/GetInstanceMetricsResult.h )
+	include/alibabacloud/eais/model/GetInstanceMetricsResult.h
+	include/alibabacloud/eais/model/StartEaisEiRequest.h
+	include/alibabacloud/eais/model/StartEaisEiResult.h
+	include/alibabacloud/eais/model/StopEaisEiRequest.h
+	include/alibabacloud/eais/model/StopEaisEiResult.h )
 
 set(eais_src 
 	src/EaisClient.cc
 	src/model/AttachEaiRequest.cc
 	src/model/AttachEaiResult.cc
+	src/model/AttachEaisEiRequest.cc
+	src/model/AttachEaisEiResult.cc
 	src/model/ChangeResourceGroupRequest.cc
 	src/model/ChangeResourceGroupResult.cc
 	src/model/CreateEaiRequest.cc
@@ -64,18 +78,28 @@ set(eais_src
 	src/model/CreateEaiEcsResult.cc
 	src/model/CreateEaiJupyterRequest.cc
 	src/model/CreateEaiJupyterResult.cc
+	src/model/CreateEaisEiRequest.cc
+	src/model/CreateEaisEiResult.cc
 	src/model/DeleteEaiRequest.cc
 	src/model/DeleteEaiResult.cc
 	src/model/DeleteEaiAllRequest.cc
 	src/model/DeleteEaiAllResult.cc
+	src/model/DeleteEaisEiRequest.cc
+	src/model/DeleteEaisEiResult.cc
 	src/model/DescribeEaisRequest.cc
 	src/model/DescribeEaisResult.cc
 	src/model/DescribeRegionsRequest.cc
 	src/model/DescribeRegionsResult.cc
 	src/model/DetachEaiRequest.cc
 	src/model/DetachEaiResult.cc
+	src/model/DetachEaisEiRequest.cc
+	src/model/DetachEaisEiResult.cc
 	src/model/GetInstanceMetricsRequest.cc
-	src/model/GetInstanceMetricsResult.cc )
+	src/model/GetInstanceMetricsResult.cc
+	src/model/StartEaisEiRequest.cc
+	src/model/StartEaisEiResult.cc
+	src/model/StopEaisEiRequest.cc
+	src/model/StopEaisEiResult.cc )
 
 add_library(eais ${LIB_TYPE}
 	${eais_public_header}

eais/include/alibabacloud/eais/EaisClient.h

@@ -24,6 +24,8 @@
 #include "EaisExport.h"
 #include "model/AttachEaiRequest.h"
 #include "model/AttachEaiResult.h"
+#include "model/AttachEaisEiRequest.h"
+#include "model/AttachEaisEiResult.h"
 #include "model/ChangeResourceGroupRequest.h"
 #include "model/ChangeResourceGroupResult.h"
 #include "model/CreateEaiRequest.h"
@@ -36,18 +38,28 @@
 #include "model/CreateEaiEcsResult.h"
 #include "model/CreateEaiJupyterRequest.h"
 #include "model/CreateEaiJupyterResult.h"
+#include "model/CreateEaisEiRequest.h"
+#include "model/CreateEaisEiResult.h"
 #include "model/DeleteEaiRequest.h"
 #include "model/DeleteEaiResult.h"
 #include "model/DeleteEaiAllRequest.h"
 #include "model/DeleteEaiAllResult.h"
+#include "model/DeleteEaisEiRequest.h"
+#include "model/DeleteEaisEiResult.h"
 #include "model/DescribeEaisRequest.h"
 #include "model/DescribeEaisResult.h"
 #include "model/DescribeRegionsRequest.h"
 #include "model/DescribeRegionsResult.h"
 #include "model/DetachEaiRequest.h"
 #include "model/DetachEaiResult.h"
+#include "model/DetachEaisEiRequest.h"
+#include "model/DetachEaisEiResult.h"
 #include "model/GetInstanceMetricsRequest.h"
 #include "model/GetInstanceMetricsResult.h"
+#include "model/StartEaisEiRequest.h"
+#include "model/StartEaisEiResult.h"
+#include "model/StopEaisEiRequest.h"
+#include "model/StopEaisEiResult.h"
 
 
 namespace AlibabaCloud
@@ -60,6 +72,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AttachEaiResult> AttachEaiOutcome;
 			typedef std::future<AttachEaiOutcome> AttachEaiOutcomeCallable;
 			typedef std::function<void(const EaisClient*, const Model::AttachEaiRequest&, const AttachEaiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachEaiAsyncHandler;
+			typedef Outcome<Error, Model::AttachEaisEiResult> AttachEaisEiOutcome;
+			typedef std::future<AttachEaisEiOutcome> AttachEaisEiOutcomeCallable;
+			typedef std::function<void(const EaisClient*, const Model::AttachEaisEiRequest&, const AttachEaisEiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachEaisEiAsyncHandler;
 			typedef Outcome<Error, Model::ChangeResourceGroupResult> ChangeResourceGroupOutcome;
 			typedef std::future<ChangeResourceGroupOutcome> ChangeResourceGroupOutcomeCallable;
 			typedef std::function<void(const EaisClient*, const Model::ChangeResourceGroupRequest&, const ChangeResourceGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ChangeResourceGroupAsyncHandler;
@@ -78,12 +93,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateEaiJupyterResult> CreateEaiJupyterOutcome;
 			typedef std::future<CreateEaiJupyterOutcome> CreateEaiJupyterOutcomeCallable;
 			typedef std::function<void(const EaisClient*, const Model::CreateEaiJupyterRequest&, const CreateEaiJupyterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateEaiJupyterAsyncHandler;
+			typedef Outcome<Error, Model::CreateEaisEiResult> CreateEaisEiOutcome;
+			typedef std::future<CreateEaisEiOutcome> CreateEaisEiOutcomeCallable;
+			typedef std::function<void(const EaisClient*, const Model::CreateEaisEiRequest&, const CreateEaisEiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateEaisEiAsyncHandler;
 			typedef Outcome<Error, Model::DeleteEaiResult> DeleteEaiOutcome;
 			typedef std::future<DeleteEaiOutcome> DeleteEaiOutcomeCallable;
 			typedef std::function<void(const EaisClient*, const Model::DeleteEaiRequest&, const DeleteEaiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteEaiAsyncHandler;
 			typedef Outcome<Error, Model::DeleteEaiAllResult> DeleteEaiAllOutcome;
 			typedef std::future<DeleteEaiAllOutcome> DeleteEaiAllOutcomeCallable;
 			typedef std::function<void(const EaisClient*, const Model::DeleteEaiAllRequest&, const DeleteEaiAllOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteEaiAllAsyncHandler;
+			typedef Outcome<Error, Model::DeleteEaisEiResult> DeleteEaisEiOutcome;
+			typedef std::future<DeleteEaisEiOutcome> DeleteEaisEiOutcomeCallable;
+			typedef std::function<void(const EaisClient*, const Model::DeleteEaisEiRequest&, const DeleteEaisEiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteEaisEiAsyncHandler;
 			typedef Outcome<Error, Model::DescribeEaisResult> DescribeEaisOutcome;
 			typedef std::future<DescribeEaisOutcome> DescribeEaisOutcomeCallable;
 			typedef std::function<void(const EaisClient*, const Model::DescribeEaisRequest&, const DescribeEaisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeEaisAsyncHandler;
@@ -93,9 +114,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DetachEaiResult> DetachEaiOutcome;
 			typedef std::future<DetachEaiOutcome> DetachEaiOutcomeCallable;
 			typedef std::function<void(const EaisClient*, const Model::DetachEaiRequest&, const DetachEaiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachEaiAsyncHandler;
+			typedef Outcome<Error, Model::DetachEaisEiResult> DetachEaisEiOutcome;
+			typedef std::future<DetachEaisEiOutcome> DetachEaisEiOutcomeCallable;
+			typedef std::function<void(const EaisClient*, const Model::DetachEaisEiRequest&, const DetachEaisEiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachEaisEiAsyncHandler;
 			typedef Outcome<Error, Model::GetInstanceMetricsResult> GetInstanceMetricsOutcome;
 			typedef std::future<GetInstanceMetricsOutcome> GetInstanceMetricsOutcomeCallable;
 			typedef std::function<void(const EaisClient*, const Model::GetInstanceMetricsRequest&, const GetInstanceMetricsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInstanceMetricsAsyncHandler;
+			typedef Outcome<Error, Model::StartEaisEiResult> StartEaisEiOutcome;
+			typedef std::future<StartEaisEiOutcome> StartEaisEiOutcomeCallable;
+			typedef std::function<void(const EaisClient*, const Model::StartEaisEiRequest&, const StartEaisEiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartEaisEiAsyncHandler;
+			typedef Outcome<Error, Model::StopEaisEiResult> StopEaisEiOutcome;
+			typedef std::future<StopEaisEiOutcome> StopEaisEiOutcomeCallable;
+			typedef std::function<void(const EaisClient*, const Model::StopEaisEiRequest&, const StopEaisEiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopEaisEiAsyncHandler;
 
 			EaisClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			EaisClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -104,6 +134,9 @@ namespace AlibabaCloud
 			AttachEaiOutcome attachEai(const Model::AttachEaiRequest &request)const;
 			void attachEaiAsync(const Model::AttachEaiRequest& request, const AttachEaiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AttachEaiOutcomeCallable attachEaiCallable(const Model::AttachEaiRequest& request) const;
+			AttachEaisEiOutcome attachEaisEi(const Model::AttachEaisEiRequest &request)const;
+			void attachEaisEiAsync(const Model::AttachEaisEiRequest& request, const AttachEaisEiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AttachEaisEiOutcomeCallable attachEaisEiCallable(const Model::AttachEaisEiRequest& request) const;
 			ChangeResourceGroupOutcome changeResourceGroup(const Model::ChangeResourceGroupRequest &request)const;
 			void changeResourceGroupAsync(const Model::ChangeResourceGroupRequest& request, const ChangeResourceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ChangeResourceGroupOutcomeCallable changeResourceGroupCallable(const Model::ChangeResourceGroupRequest& request) const;
@@ -122,12 +155,18 @@ namespace AlibabaCloud
 			CreateEaiJupyterOutcome createEaiJupyter(const Model::CreateEaiJupyterRequest &request)const;
 			void createEaiJupyterAsync(const Model::CreateEaiJupyterRequest& request, const CreateEaiJupyterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateEaiJupyterOutcomeCallable createEaiJupyterCallable(const Model::CreateEaiJupyterRequest& request) const;
+			CreateEaisEiOutcome createEaisEi(const Model::CreateEaisEiRequest &request)const;
+			void createEaisEiAsync(const Model::CreateEaisEiRequest& request, const CreateEaisEiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateEaisEiOutcomeCallable createEaisEiCallable(const Model::CreateEaisEiRequest& request) const;
 			DeleteEaiOutcome deleteEai(const Model::DeleteEaiRequest &request)const;
 			void deleteEaiAsync(const Model::DeleteEaiRequest& request, const DeleteEaiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteEaiOutcomeCallable deleteEaiCallable(const Model::DeleteEaiRequest& request) const;
 			DeleteEaiAllOutcome deleteEaiAll(const Model::DeleteEaiAllRequest &request)const;
 			void deleteEaiAllAsync(const Model::DeleteEaiAllRequest& request, const DeleteEaiAllAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteEaiAllOutcomeCallable deleteEaiAllCallable(const Model::DeleteEaiAllRequest& request) const;
+			DeleteEaisEiOutcome deleteEaisEi(const Model::DeleteEaisEiRequest &request)const;
+			void deleteEaisEiAsync(const Model::DeleteEaisEiRequest& request, const DeleteEaisEiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteEaisEiOutcomeCallable deleteEaisEiCallable(const Model::DeleteEaisEiRequest& request) const;
 			DescribeEaisOutcome describeEais(const Model::DescribeEaisRequest &request)const;
 			void describeEaisAsync(const Model::DescribeEaisRequest& request, const DescribeEaisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeEaisOutcomeCallable describeEaisCallable(const Model::DescribeEaisRequest& request) const;
@@ -137,9 +176,18 @@ namespace AlibabaCloud
 			DetachEaiOutcome detachEai(const Model::DetachEaiRequest &request)const;
 			void detachEaiAsync(const Model::DetachEaiRequest& request, const DetachEaiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetachEaiOutcomeCallable detachEaiCallable(const Model::DetachEaiRequest& request) const;
+			DetachEaisEiOutcome detachEaisEi(const Model::DetachEaisEiRequest &request)const;
+			void detachEaisEiAsync(const Model::DetachEaisEiRequest& request, const DetachEaisEiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetachEaisEiOutcomeCallable detachEaisEiCallable(const Model::DetachEaisEiRequest& request) const;
 			GetInstanceMetricsOutcome getInstanceMetrics(const Model::GetInstanceMetricsRequest &request)const;
 			void getInstanceMetricsAsync(const Model::GetInstanceMetricsRequest& request, const GetInstanceMetricsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetInstanceMetricsOutcomeCallable getInstanceMetricsCallable(const Model::GetInstanceMetricsRequest& request) const;
+			StartEaisEiOutcome startEaisEi(const Model::StartEaisEiRequest &request)const;
+			void startEaisEiAsync(const Model::StartEaisEiRequest& request, const StartEaisEiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartEaisEiOutcomeCallable startEaisEiCallable(const Model::StartEaisEiRequest& request) const;
+			StopEaisEiOutcome stopEaisEi(const Model::StopEaisEiRequest &request)const;
+			void stopEaisEiAsync(const Model::StopEaisEiRequest& request, const StopEaisEiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopEaisEiOutcomeCallable stopEaisEiCallable(const Model::StopEaisEiRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

eais/include/alibabacloud/eais/model/AttachEaisEiRequest.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_EAIS_MODEL_ATTACHEAISEIREQUEST_H_
+#define ALIBABACLOUD_EAIS_MODEL_ATTACHEAISEIREQUEST_H_
+
+#include <alibabacloud/eais/EaisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eais {
+namespace Model {
+class ALIBABACLOUD_EAIS_EXPORT AttachEaisEiRequest : public RpcServiceRequest {
+public:
+	AttachEaisEiRequest();
+	~AttachEaisEiRequest();
+	std::string getEiInstanceType() const;
+	void setEiInstanceType(const std::string &eiInstanceType);
+	std::string getClientInstanceId() const;
+	void setClientInstanceId(const std::string &clientInstanceId);
+	std::string getEiInstanceId() const;
+	void setEiInstanceId(const std::string &eiInstanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string eiInstanceType_;
+	std::string clientInstanceId_;
+	std::string eiInstanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eais
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EAIS_MODEL_ATTACHEAISEIREQUEST_H_

eais/include/alibabacloud/eais/model/AttachEaisEiResult.h

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

eais/include/alibabacloud/eais/model/CreateEaiJupyterRequest.h

@@ -48,6 +48,8 @@ public:
 	void setRegionId(const std::string &regionId);
 	std::vector<EnvironmentVar> getEnvironmentVar() const;
 	void setEnvironmentVar(const std::vector<EnvironmentVar> &environmentVar);
+	std::string getEaisName() const;
+	void setEaisName(const std::string &eaisName);
 
 private:
 	std::string clientToken_;
@@ -57,6 +59,7 @@ private:
 	std::string resourceGroupId_;
 	std::string regionId_;
 	std::vector<EnvironmentVar> environmentVar_;
+	std::string eaisName_;
 };
 } // namespace Model
 } // namespace Eais

eais/include/alibabacloud/eais/model/CreateEaiRequest.h

@@ -30,6 +30,8 @@ class ALIBABACLOUD_EAIS_EXPORT CreateEaiRequest : public RpcServiceRequest {
 public:
 	CreateEaiRequest();
 	~CreateEaiRequest();
+	std::string getImage() const;
+	void setImage(const std::string &image);
 	std::string getClientToken() const;
 	void setClientToken(const std::string &clientToken);
 	std::string getSecurityGroupId() const;
@@ -46,6 +48,7 @@ public:
 	void setInstanceType(const std::string &instanceType);
 
 private:
+	std::string image_;
 	std::string clientToken_;
 	std::string securityGroupId_;
 	std::string vSwitchId_;

eais/include/alibabacloud/eais/model/CreateEaisEiRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EAIS_MODEL_CREATEEAISEIREQUEST_H_
+#define ALIBABACLOUD_EAIS_MODEL_CREATEEAISEIREQUEST_H_
+
+#include <alibabacloud/eais/EaisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eais {
+namespace Model {
+class ALIBABACLOUD_EAIS_EXPORT CreateEaisEiRequest : public RpcServiceRequest {
+public:
+	CreateEaisEiRequest();
+	~CreateEaisEiRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getSecurityGroupId() const;
+	void setSecurityGroupId(const std::string &securityGroupId);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getInstanceName() const;
+	void setInstanceName(const std::string &instanceName);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getInstanceType() const;
+	void setInstanceType(const std::string &instanceType);
+
+private:
+	std::string clientToken_;
+	std::string securityGroupId_;
+	std::string vSwitchId_;
+	std::string resourceGroupId_;
+	std::string instanceName_;
+	std::string regionId_;
+	std::string instanceType_;
+};
+} // namespace Model
+} // namespace Eais
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EAIS_MODEL_CREATEEAISEIREQUEST_H_

eais/include/alibabacloud/eais/model/CreateEaisEiResult.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_EAIS_MODEL_CREATEEAISEIRESULT_H_
+#define ALIBABACLOUD_EAIS_MODEL_CREATEEAISEIRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eais/EaisExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eais
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EAIS_EXPORT CreateEaisEiResult : public ServiceResult
+			{
+			public:
+
+
+				CreateEaisEiResult();
+				explicit CreateEaisEiResult(const std::string &payload);
+				~CreateEaisEiResult();
+				std::string getEiInstanceId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string eiInstanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EAIS_MODEL_CREATEEAISEIRESULT_H_

eais/include/alibabacloud/eais/model/DeleteEaisEiRequest.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_EAIS_MODEL_DELETEEAISEIREQUEST_H_
+#define ALIBABACLOUD_EAIS_MODEL_DELETEEAISEIREQUEST_H_
+
+#include <alibabacloud/eais/EaisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eais {
+namespace Model {
+class ALIBABACLOUD_EAIS_EXPORT DeleteEaisEiRequest : public RpcServiceRequest {
+public:
+	DeleteEaisEiRequest();
+	~DeleteEaisEiRequest();
+	std::string getEiInstanceId() const;
+	void setEiInstanceId(const std::string &eiInstanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getForce() const;
+	void setForce(bool force);
+
+private:
+	std::string eiInstanceId_;
+	std::string regionId_;
+	bool force_;
+};
+} // namespace Model
+} // namespace Eais
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EAIS_MODEL_DELETEEAISEIREQUEST_H_

eais/include/alibabacloud/eais/model/DeleteEaisEiResult.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_EAIS_MODEL_DELETEEAISEIRESULT_H_
+#define ALIBABACLOUD_EAIS_MODEL_DELETEEAISEIRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eais/EaisExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eais
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EAIS_EXPORT DeleteEaisEiResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteEaisEiResult();
+				explicit DeleteEaisEiResult(const std::string &payload);
+				~DeleteEaisEiResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EAIS_MODEL_DELETEEAISEIRESULT_H_

eais/include/alibabacloud/eais/model/DetachEaisEiRequest.h

@@ -0,0 +1,45 @@
+/*
+ * 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_EAIS_MODEL_DETACHEAISEIREQUEST_H_
+#define ALIBABACLOUD_EAIS_MODEL_DETACHEAISEIREQUEST_H_
+
+#include <alibabacloud/eais/EaisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eais {
+namespace Model {
+class ALIBABACLOUD_EAIS_EXPORT DetachEaisEiRequest : public RpcServiceRequest {
+public:
+	DetachEaisEiRequest();
+	~DetachEaisEiRequest();
+	std::string getEiInstanceId() const;
+	void setEiInstanceId(const std::string &eiInstanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string eiInstanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eais
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EAIS_MODEL_DETACHEAISEIREQUEST_H_

eais/include/alibabacloud/eais/model/DetachEaisEiResult.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_EAIS_MODEL_DETACHEAISEIRESULT_H_
+#define ALIBABACLOUD_EAIS_MODEL_DETACHEAISEIRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eais/EaisExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eais
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EAIS_EXPORT DetachEaisEiResult : public ServiceResult
+			{
+			public:
+
+
+				DetachEaisEiResult();
+				explicit DetachEaisEiResult(const std::string &payload);
+				~DetachEaisEiResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EAIS_MODEL_DETACHEAISEIRESULT_H_

eais/include/alibabacloud/eais/model/GetInstanceMetricsRequest.h

@@ -40,6 +40,8 @@ public:
 	void setStartTime(const std::string &startTime);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
 
 private:
 	std::string metricType_;
@@ -47,6 +49,7 @@ private:
 	std::string endTime_;
 	std::string startTime_;
 	std::string instanceId_;
+	std::string regionId_;
 };
 } // namespace Model
 } // namespace Eais

eais/include/alibabacloud/eais/model/StartEaisEiRequest.h

@@ -0,0 +1,45 @@
+/*
+ * 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_EAIS_MODEL_STARTEAISEIREQUEST_H_
+#define ALIBABACLOUD_EAIS_MODEL_STARTEAISEIREQUEST_H_
+
+#include <alibabacloud/eais/EaisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eais {
+namespace Model {
+class ALIBABACLOUD_EAIS_EXPORT StartEaisEiRequest : public RpcServiceRequest {
+public:
+	StartEaisEiRequest();
+	~StartEaisEiRequest();
+	std::string getEiInstanceId() const;
+	void setEiInstanceId(const std::string &eiInstanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string eiInstanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eais
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EAIS_MODEL_STARTEAISEIREQUEST_H_

eais/include/alibabacloud/eais/model/StartEaisEiResult.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_EAIS_MODEL_STARTEAISEIRESULT_H_
+#define ALIBABACLOUD_EAIS_MODEL_STARTEAISEIRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eais/EaisExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eais
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EAIS_EXPORT StartEaisEiResult : public ServiceResult
+			{
+			public:
+
+
+				StartEaisEiResult();
+				explicit StartEaisEiResult(const std::string &payload);
+				~StartEaisEiResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EAIS_MODEL_STARTEAISEIRESULT_H_

eais/include/alibabacloud/eais/model/StopEaisEiRequest.h

@@ -0,0 +1,45 @@
+/*
+ * 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_EAIS_MODEL_STOPEAISEIREQUEST_H_
+#define ALIBABACLOUD_EAIS_MODEL_STOPEAISEIREQUEST_H_
+
+#include <alibabacloud/eais/EaisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eais {
+namespace Model {
+class ALIBABACLOUD_EAIS_EXPORT StopEaisEiRequest : public RpcServiceRequest {
+public:
+	StopEaisEiRequest();
+	~StopEaisEiRequest();
+	std::string getEiInstanceId() const;
+	void setEiInstanceId(const std::string &eiInstanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string eiInstanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eais
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EAIS_MODEL_STOPEAISEIREQUEST_H_

eais/include/alibabacloud/eais/model/StopEaisEiResult.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_EAIS_MODEL_STOPEAISEIRESULT_H_
+#define ALIBABACLOUD_EAIS_MODEL_STOPEAISEIRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eais/EaisExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eais
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EAIS_EXPORT StopEaisEiResult : public ServiceResult
+			{
+			public:
+
+
+				StopEaisEiResult();
+				explicit StopEaisEiResult(const std::string &payload);
+				~StopEaisEiResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EAIS_MODEL_STOPEAISEIRESULT_H_

eais/src/EaisClient.cc

@@ -87,6 +87,42 @@ EaisClient::AttachEaiOutcomeCallable EaisClient::attachEaiCallable(const AttachE
 	return task->get_future();
 }
 
+EaisClient::AttachEaisEiOutcome EaisClient::attachEaisEi(const AttachEaisEiRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AttachEaisEiOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AttachEaisEiOutcome(AttachEaisEiResult(outcome.result()));
+	else
+		return AttachEaisEiOutcome(outcome.error());
+}
+
+void EaisClient::attachEaisEiAsync(const AttachEaisEiRequest& request, const AttachEaisEiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, attachEaisEi(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EaisClient::AttachEaisEiOutcomeCallable EaisClient::attachEaisEiCallable(const AttachEaisEiRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AttachEaisEiOutcome()>>(
+			[this, request]()
+			{
+			return this->attachEaisEi(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EaisClient::ChangeResourceGroupOutcome EaisClient::changeResourceGroup(const ChangeResourceGroupRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -303,6 +339,42 @@ EaisClient::CreateEaiJupyterOutcomeCallable EaisClient::createEaiJupyterCallable
 	return task->get_future();
 }
 
+EaisClient::CreateEaisEiOutcome EaisClient::createEaisEi(const CreateEaisEiRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateEaisEiOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateEaisEiOutcome(CreateEaisEiResult(outcome.result()));
+	else
+		return CreateEaisEiOutcome(outcome.error());
+}
+
+void EaisClient::createEaisEiAsync(const CreateEaisEiRequest& request, const CreateEaisEiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createEaisEi(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EaisClient::CreateEaisEiOutcomeCallable EaisClient::createEaisEiCallable(const CreateEaisEiRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateEaisEiOutcome()>>(
+			[this, request]()
+			{
+			return this->createEaisEi(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EaisClient::DeleteEaiOutcome EaisClient::deleteEai(const DeleteEaiRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -375,6 +447,42 @@ EaisClient::DeleteEaiAllOutcomeCallable EaisClient::deleteEaiAllCallable(const D
 	return task->get_future();
 }
 
+EaisClient::DeleteEaisEiOutcome EaisClient::deleteEaisEi(const DeleteEaisEiRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteEaisEiOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteEaisEiOutcome(DeleteEaisEiResult(outcome.result()));
+	else
+		return DeleteEaisEiOutcome(outcome.error());
+}
+
+void EaisClient::deleteEaisEiAsync(const DeleteEaisEiRequest& request, const DeleteEaisEiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteEaisEi(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EaisClient::DeleteEaisEiOutcomeCallable EaisClient::deleteEaisEiCallable(const DeleteEaisEiRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteEaisEiOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteEaisEi(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EaisClient::DescribeEaisOutcome EaisClient::describeEais(const DescribeEaisRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -483,6 +591,42 @@ EaisClient::DetachEaiOutcomeCallable EaisClient::detachEaiCallable(const DetachE
 	return task->get_future();
 }
 
+EaisClient::DetachEaisEiOutcome EaisClient::detachEaisEi(const DetachEaisEiRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetachEaisEiOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetachEaisEiOutcome(DetachEaisEiResult(outcome.result()));
+	else
+		return DetachEaisEiOutcome(outcome.error());
+}
+
+void EaisClient::detachEaisEiAsync(const DetachEaisEiRequest& request, const DetachEaisEiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detachEaisEi(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EaisClient::DetachEaisEiOutcomeCallable EaisClient::detachEaisEiCallable(const DetachEaisEiRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetachEaisEiOutcome()>>(
+			[this, request]()
+			{
+			return this->detachEaisEi(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EaisClient::GetInstanceMetricsOutcome EaisClient::getInstanceMetrics(const GetInstanceMetricsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -519,3 +663,75 @@ EaisClient::GetInstanceMetricsOutcomeCallable EaisClient::getInstanceMetricsCall
 	return task->get_future();
 }
 
+EaisClient::StartEaisEiOutcome EaisClient::startEaisEi(const StartEaisEiRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartEaisEiOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartEaisEiOutcome(StartEaisEiResult(outcome.result()));
+	else
+		return StartEaisEiOutcome(outcome.error());
+}
+
+void EaisClient::startEaisEiAsync(const StartEaisEiRequest& request, const StartEaisEiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startEaisEi(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EaisClient::StartEaisEiOutcomeCallable EaisClient::startEaisEiCallable(const StartEaisEiRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartEaisEiOutcome()>>(
+			[this, request]()
+			{
+			return this->startEaisEi(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EaisClient::StopEaisEiOutcome EaisClient::stopEaisEi(const StopEaisEiRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopEaisEiOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopEaisEiOutcome(StopEaisEiResult(outcome.result()));
+	else
+		return StopEaisEiOutcome(outcome.error());
+}
+
+void EaisClient::stopEaisEiAsync(const StopEaisEiRequest& request, const StopEaisEiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopEaisEi(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EaisClient::StopEaisEiOutcomeCallable EaisClient::stopEaisEiCallable(const StopEaisEiRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopEaisEiOutcome()>>(
+			[this, request]()
+			{
+			return this->stopEaisEi(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

eais/src/model/AttachEaisEiRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eais/model/AttachEaisEiRequest.h>
+
+using AlibabaCloud::Eais::Model::AttachEaisEiRequest;
+
+AttachEaisEiRequest::AttachEaisEiRequest()
+    : RpcServiceRequest("eais", "2019-06-24", "AttachEaisEi") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AttachEaisEiRequest::~AttachEaisEiRequest() {}
+
+std::string AttachEaisEiRequest::getEiInstanceType() const {
+  return eiInstanceType_;
+}
+
+void AttachEaisEiRequest::setEiInstanceType(const std::string &eiInstanceType) {
+  eiInstanceType_ = eiInstanceType;
+  setParameter(std::string("EiInstanceType"), eiInstanceType);
+}
+
+std::string AttachEaisEiRequest::getClientInstanceId() const {
+  return clientInstanceId_;
+}
+
+void AttachEaisEiRequest::setClientInstanceId(const std::string &clientInstanceId) {
+  clientInstanceId_ = clientInstanceId;
+  setParameter(std::string("ClientInstanceId"), clientInstanceId);
+}
+
+std::string AttachEaisEiRequest::getEiInstanceId() const {
+  return eiInstanceId_;
+}
+
+void AttachEaisEiRequest::setEiInstanceId(const std::string &eiInstanceId) {
+  eiInstanceId_ = eiInstanceId;
+  setParameter(std::string("EiInstanceId"), eiInstanceId);
+}
+
+std::string AttachEaisEiRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AttachEaisEiRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

eais/src/model/AttachEaisEiResult.cc

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

eais/src/model/CreateEaiJupyterRequest.cc

@@ -91,3 +91,12 @@ void CreateEaiJupyterRequest::setEnvironmentVar(const std::vector<CreateEaiJupyt
   }
 }
 
+std::string CreateEaiJupyterRequest::getEaisName() const {
+  return eaisName_;
+}
+
+void CreateEaiJupyterRequest::setEaisName(const std::string &eaisName) {
+  eaisName_ = eaisName;
+  setParameter(std::string("EaisName"), eaisName);
+}
+

eais/src/model/CreateEaiRequest.cc

@@ -25,6 +25,15 @@ CreateEaiRequest::CreateEaiRequest()
 
 CreateEaiRequest::~CreateEaiRequest() {}
 
+std::string CreateEaiRequest::getImage() const {
+  return image_;
+}
+
+void CreateEaiRequest::setImage(const std::string &image) {
+  image_ = image;
+  setParameter(std::string("Image"), image);
+}
+
 std::string CreateEaiRequest::getClientToken() const {
   return clientToken_;
 }

eais/src/model/CreateEaisEiRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * 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/eais/model/CreateEaisEiRequest.h>
+
+using AlibabaCloud::Eais::Model::CreateEaisEiRequest;
+
+CreateEaisEiRequest::CreateEaisEiRequest()
+    : RpcServiceRequest("eais", "2019-06-24", "CreateEaisEi") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateEaisEiRequest::~CreateEaisEiRequest() {}
+
+std::string CreateEaisEiRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateEaisEiRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateEaisEiRequest::getSecurityGroupId() const {
+  return securityGroupId_;
+}
+
+void CreateEaisEiRequest::setSecurityGroupId(const std::string &securityGroupId) {
+  securityGroupId_ = securityGroupId;
+  setParameter(std::string("SecurityGroupId"), securityGroupId);
+}
+
+std::string CreateEaisEiRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void CreateEaisEiRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
+std::string CreateEaisEiRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void CreateEaisEiRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string CreateEaisEiRequest::getInstanceName() const {
+  return instanceName_;
+}
+
+void CreateEaisEiRequest::setInstanceName(const std::string &instanceName) {
+  instanceName_ = instanceName;
+  setParameter(std::string("InstanceName"), instanceName);
+}
+
+std::string CreateEaisEiRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateEaisEiRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateEaisEiRequest::getInstanceType() const {
+  return instanceType_;
+}
+
+void CreateEaisEiRequest::setInstanceType(const std::string &instanceType) {
+  instanceType_ = instanceType;
+  setParameter(std::string("InstanceType"), instanceType);
+}
+

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

eais/src/model/DeleteEaisEiRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/eais/model/DeleteEaisEiRequest.h>
+
+using AlibabaCloud::Eais::Model::DeleteEaisEiRequest;
+
+DeleteEaisEiRequest::DeleteEaisEiRequest()
+    : RpcServiceRequest("eais", "2019-06-24", "DeleteEaisEi") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteEaisEiRequest::~DeleteEaisEiRequest() {}
+
+std::string DeleteEaisEiRequest::getEiInstanceId() const {
+  return eiInstanceId_;
+}
+
+void DeleteEaisEiRequest::setEiInstanceId(const std::string &eiInstanceId) {
+  eiInstanceId_ = eiInstanceId;
+  setParameter(std::string("EiInstanceId"), eiInstanceId);
+}
+
+std::string DeleteEaisEiRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteEaisEiRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+bool DeleteEaisEiRequest::getForce() const {
+  return force_;
+}
+
+void DeleteEaisEiRequest::setForce(bool force) {
+  force_ = force;
+  setParameter(std::string("Force"), force ? "true" : "false");
+}
+

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

eais/src/model/DetachEaisEiRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/eais/model/DetachEaisEiRequest.h>
+
+using AlibabaCloud::Eais::Model::DetachEaisEiRequest;
+
+DetachEaisEiRequest::DetachEaisEiRequest()
+    : RpcServiceRequest("eais", "2019-06-24", "DetachEaisEi") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DetachEaisEiRequest::~DetachEaisEiRequest() {}
+
+std::string DetachEaisEiRequest::getEiInstanceId() const {
+  return eiInstanceId_;
+}
+
+void DetachEaisEiRequest::setEiInstanceId(const std::string &eiInstanceId) {
+  eiInstanceId_ = eiInstanceId;
+  setParameter(std::string("EiInstanceId"), eiInstanceId);
+}
+
+std::string DetachEaisEiRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DetachEaisEiRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

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

eais/src/model/GetInstanceMetricsRequest.cc

@@ -70,3 +70,12 @@ void GetInstanceMetricsRequest::setInstanceId(const std::string &instanceId) {
   setParameter(std::string("InstanceId"), instanceId);
 }
 
+std::string GetInstanceMetricsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetInstanceMetricsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

eais/src/model/StartEaisEiRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/eais/model/StartEaisEiRequest.h>
+
+using AlibabaCloud::Eais::Model::StartEaisEiRequest;
+
+StartEaisEiRequest::StartEaisEiRequest()
+    : RpcServiceRequest("eais", "2019-06-24", "StartEaisEi") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+StartEaisEiRequest::~StartEaisEiRequest() {}
+
+std::string StartEaisEiRequest::getEiInstanceId() const {
+  return eiInstanceId_;
+}
+
+void StartEaisEiRequest::setEiInstanceId(const std::string &eiInstanceId) {
+  eiInstanceId_ = eiInstanceId;
+  setParameter(std::string("EiInstanceId"), eiInstanceId);
+}
+
+std::string StartEaisEiRequest::getRegionId() const {
+  return regionId_;
+}
+
+void StartEaisEiRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

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

eais/src/model/StopEaisEiRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/eais/model/StopEaisEiRequest.h>
+
+using AlibabaCloud::Eais::Model::StopEaisEiRequest;
+
+StopEaisEiRequest::StopEaisEiRequest()
+    : RpcServiceRequest("eais", "2019-06-24", "StopEaisEi") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+StopEaisEiRequest::~StopEaisEiRequest() {}
+
+std::string StopEaisEiRequest::getEiInstanceId() const {
+  return eiInstanceId_;
+}
+
+void StopEaisEiRequest::setEiInstanceId(const std::string &eiInstanceId) {
+  eiInstanceId_ = eiInstanceId;
+  setParameter(std::string("EiInstanceId"), eiInstanceId);
+}
+
+std::string StopEaisEiRequest::getRegionId() const {
+  return regionId_;
+}
+
+void StopEaisEiRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

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

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_