test: add macosx into jobs

.github/workflows/test.yaml

@@ -0,0 +1,29 @@
+name: Test
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macosx-latest]
+    runs-on: ${{ matrix.os }}
+    env:
+      CPLUS_INCLUDE_PATH: "/usr/local/include/:/usr/include/jsoncpp/:/usr/local/opt/openssl/include/:/usr/lib/"
+    steps:
+      - uses: actions/checkout@v3
+
+      - if: ${{ matrix.os == 'ubuntu-latest' }}
+        run: sudo apt-get install lcov libcurl4-openssl-dev libssl-dev uuid-dev libjson-c-dev libjsoncpp-dev nodejs npm
+      - if: ${{ matrix.os == 'macosx-latest' }}
+        run: brew install lcov libcurl4-openssl-dev libssl-dev uuid-dev libjson-c-dev libjsoncpp-dev nodejs npm
+
+      - run: bash ./unit_test.sh
+      - run: bash ./generate_code_cov.sh
+      - run: bash ./function_test.sh
+      - run: bash <(curl -s https://codecov.io/bash)

.gitignore

@@ -14,3 +14,4 @@ test/httpserver/nohup.out
 .idea
 build/
 cmake-build-debug/
+.DS_Store

VERSION

@@ -1 +1 @@
-1.36.1726
+1.36.1758

adb/CMakeLists.txt

@@ -179,6 +179,8 @@ set(adb_public_header_model
 	include/alibabacloud/adb/model/KillProcessResult.h
 	include/alibabacloud/adb/model/ListTagResourcesRequest.h
 	include/alibabacloud/adb/model/ListTagResourcesResult.h
+	include/alibabacloud/adb/model/MigrateDBClusterRequest.h
+	include/alibabacloud/adb/model/MigrateDBClusterResult.h
 	include/alibabacloud/adb/model/ModifyAccountDescriptionRequest.h
 	include/alibabacloud/adb/model/ModifyAccountDescriptionResult.h
 	include/alibabacloud/adb/model/ModifyAuditLogConfigRequest.h
@@ -386,6 +388,8 @@ set(adb_src
 	src/model/KillProcessResult.cc
 	src/model/ListTagResourcesRequest.cc
 	src/model/ListTagResourcesResult.cc
+	src/model/MigrateDBClusterRequest.cc
+	src/model/MigrateDBClusterResult.cc
 	src/model/ModifyAccountDescriptionRequest.cc
 	src/model/ModifyAccountDescriptionResult.cc
 	src/model/ModifyAuditLogConfigRequest.cc

adb/include/alibabacloud/adb/AdbClient.h

@@ -180,6 +180,8 @@
 #include "model/KillProcessResult.h"
 #include "model/ListTagResourcesRequest.h"
 #include "model/ListTagResourcesResult.h"
+#include "model/MigrateDBClusterRequest.h"
+#include "model/MigrateDBClusterResult.h"
 #include "model/ModifyAccountDescriptionRequest.h"
 #include "model/ModifyAccountDescriptionResult.h"
 #include "model/ModifyAuditLogConfigRequest.h"
@@ -472,6 +474,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
 			typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
 			typedef std::function<void(const AdbClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
+			typedef Outcome<Error, Model::MigrateDBClusterResult> MigrateDBClusterOutcome;
+			typedef std::future<MigrateDBClusterOutcome> MigrateDBClusterOutcomeCallable;
+			typedef std::function<void(const AdbClient*, const Model::MigrateDBClusterRequest&, const MigrateDBClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MigrateDBClusterAsyncHandler;
 			typedef Outcome<Error, Model::ModifyAccountDescriptionResult> ModifyAccountDescriptionOutcome;
 			typedef std::future<ModifyAccountDescriptionOutcome> ModifyAccountDescriptionOutcomeCallable;
 			typedef std::function<void(const AdbClient*, const Model::ModifyAccountDescriptionRequest&, const ModifyAccountDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAccountDescriptionAsyncHandler;
@@ -783,6 +788,9 @@ namespace AlibabaCloud
 			ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
 			void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
+			MigrateDBClusterOutcome migrateDBCluster(const Model::MigrateDBClusterRequest &request)const;
+			void migrateDBClusterAsync(const Model::MigrateDBClusterRequest& request, const MigrateDBClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			MigrateDBClusterOutcomeCallable migrateDBClusterCallable(const Model::MigrateDBClusterRequest& request) const;
 			ModifyAccountDescriptionOutcome modifyAccountDescription(const Model::ModifyAccountDescriptionRequest &request)const;
 			void modifyAccountDescriptionAsync(const Model::ModifyAccountDescriptionRequest& request, const ModifyAccountDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyAccountDescriptionOutcomeCallable modifyAccountDescriptionCallable(const Model::ModifyAccountDescriptionRequest& request) const;

adb/include/alibabacloud/adb/model/DescribeComputeResourceRequest.h

@@ -38,6 +38,8 @@ public:
 	void setRegionId(const std::string &regionId);
 	std::string getResourceOwnerAccount() const;
 	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
 	std::string getOwnerAccount() const;
 	void setOwnerAccount(const std::string &ownerAccount);
 	std::string getDBClusterVersion() const;
@@ -46,16 +48,20 @@ public:
 	void setOwnerId(long ownerId);
 	std::string getZoneId() const;
 	void setZoneId(const std::string &zoneId);
+	bool getMigrate() const;
+	void setMigrate(bool migrate);
 
 private:
 	long resourceOwnerId_;
 	std::string accessKeyId_;
 	std::string regionId_;
 	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
 	std::string ownerAccount_;
 	std::string dBClusterVersion_;
 	long ownerId_;
 	std::string zoneId_;
+	bool migrate_;
 };
 } // namespace Model
 } // namespace Adb

adb/include/alibabacloud/adb/model/DescribeTablesRequest.h

@@ -34,6 +34,8 @@ public:
 	void setResourceOwnerId(long resourceOwnerId);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
 	std::string getSchemaName() const;
 	void setSchemaName(const std::string &schemaName);
 	std::string getResourceOwnerAccount() const;
@@ -48,6 +50,7 @@ public:
 private:
 	long resourceOwnerId_;
 	std::string accessKeyId_;
+	std::string regionId_;
 	std::string schemaName_;
 	std::string resourceOwnerAccount_;
 	std::string dBClusterId_;

adb/include/alibabacloud/adb/model/MigrateDBClusterRequest.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_ADB_MODEL_MIGRATEDBCLUSTERREQUEST_H_
+#define ALIBABACLOUD_ADB_MODEL_MIGRATEDBCLUSTERREQUEST_H_
+
+#include <alibabacloud/adb/AdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adb {
+namespace Model {
+class ALIBABACLOUD_ADB_EXPORT MigrateDBClusterRequest : public RpcServiceRequest {
+public:
+	MigrateDBClusterRequest();
+	~MigrateDBClusterRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string accessKeyId_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Adb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADB_MODEL_MIGRATEDBCLUSTERREQUEST_H_

adb/include/alibabacloud/adb/model/MigrateDBClusterResult.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_ADB_MODEL_MIGRATEDBCLUSTERRESULT_H_
+#define ALIBABACLOUD_ADB_MODEL_MIGRATEDBCLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/adb/AdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Adb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADB_EXPORT MigrateDBClusterResult : public ServiceResult
+			{
+			public:
+
+
+				MigrateDBClusterResult();
+				explicit MigrateDBClusterResult(const std::string &payload);
+				~MigrateDBClusterResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADB_MODEL_MIGRATEDBCLUSTERRESULT_H_

adb/src/AdbClient.cc

@@ -2895,6 +2895,42 @@ AdbClient::ListTagResourcesOutcomeCallable AdbClient::listTagResourcesCallable(c
 	return task->get_future();
 }
 
+AdbClient::MigrateDBClusterOutcome AdbClient::migrateDBCluster(const MigrateDBClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return MigrateDBClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return MigrateDBClusterOutcome(MigrateDBClusterResult(outcome.result()));
+	else
+		return MigrateDBClusterOutcome(outcome.error());
+}
+
+void AdbClient::migrateDBClusterAsync(const MigrateDBClusterRequest& request, const MigrateDBClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, migrateDBCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::MigrateDBClusterOutcomeCallable AdbClient::migrateDBClusterCallable(const MigrateDBClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<MigrateDBClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->migrateDBCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::ModifyAccountDescriptionOutcome AdbClient::modifyAccountDescription(const ModifyAccountDescriptionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

adb/src/model/DescribeComputeResourceRequest.cc

@@ -61,6 +61,15 @@ void DescribeComputeResourceRequest::setResourceOwnerAccount(const std::string &
   setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
+std::string DescribeComputeResourceRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DescribeComputeResourceRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
 std::string DescribeComputeResourceRequest::getOwnerAccount() const {
   return ownerAccount_;
 }
@@ -97,3 +106,12 @@ void DescribeComputeResourceRequest::setZoneId(const std::string &zoneId) {
   setParameter(std::string("ZoneId"), zoneId);
 }
 
+bool DescribeComputeResourceRequest::getMigrate() const {
+  return migrate_;
+}
+
+void DescribeComputeResourceRequest::setMigrate(bool migrate) {
+  migrate_ = migrate;
+  setParameter(std::string("Migrate"), migrate ? "true" : "false");
+}
+

adb/src/model/DescribeTablesRequest.cc

@@ -43,6 +43,15 @@ void DescribeTablesRequest::setAccessKeyId(const std::string &accessKeyId) {
   setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
+std::string DescribeTablesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeTablesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
 std::string DescribeTablesRequest::getSchemaName() const {
   return schemaName_;
 }

adb/src/model/MigrateDBClusterRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/adb/model/MigrateDBClusterRequest.h>
+
+using AlibabaCloud::Adb::Model::MigrateDBClusterRequest;
+
+MigrateDBClusterRequest::MigrateDBClusterRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "MigrateDBCluster") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+MigrateDBClusterRequest::~MigrateDBClusterRequest() {}
+
+long MigrateDBClusterRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void MigrateDBClusterRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string MigrateDBClusterRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void MigrateDBClusterRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string MigrateDBClusterRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void MigrateDBClusterRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string MigrateDBClusterRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void MigrateDBClusterRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string MigrateDBClusterRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void MigrateDBClusterRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long MigrateDBClusterRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void MigrateDBClusterRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

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

avatar/CMakeLists.txt

@@ -43,6 +43,8 @@ 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/QueryVideoTaskInfoRequest.h
+	include/alibabacloud/avatar/model/QueryVideoTaskInfoResult.h
 	include/alibabacloud/avatar/model/SendCommandRequest.h
 	include/alibabacloud/avatar/model/SendCommandResult.h
 	include/alibabacloud/avatar/model/SendMessageRequest.h
@@ -92,6 +94,8 @@ set(avatar_src
 	src/model/QueryRunningInstanceResult.cc
 	src/model/QueryTimedResetOperateStatusRequest.cc
 	src/model/QueryTimedResetOperateStatusResult.cc
+	src/model/QueryVideoTaskInfoRequest.cc
+	src/model/QueryVideoTaskInfoResult.cc
 	src/model/SendCommandRequest.cc
 	src/model/SendCommandResult.cc
 	src/model/SendMessageRequest.cc

avatar/include/alibabacloud/avatar/AvatarClient.h

@@ -44,6 +44,8 @@
 #include "model/QueryRunningInstanceResult.h"
 #include "model/QueryTimedResetOperateStatusRequest.h"
 #include "model/QueryTimedResetOperateStatusResult.h"
+#include "model/QueryVideoTaskInfoRequest.h"
+#include "model/QueryVideoTaskInfoResult.h"
 #include "model/SendCommandRequest.h"
 #include "model/SendCommandResult.h"
 #include "model/SendMessageRequest.h"
@@ -110,6 +112,9 @@ 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::QueryVideoTaskInfoResult> QueryVideoTaskInfoOutcome;
+			typedef std::future<QueryVideoTaskInfoOutcome> QueryVideoTaskInfoOutcomeCallable;
+			typedef std::function<void(const AvatarClient*, const Model::QueryVideoTaskInfoRequest&, const QueryVideoTaskInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryVideoTaskInfoAsyncHandler;
 			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;
@@ -184,6 +189,9 @@ 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;
+			QueryVideoTaskInfoOutcome queryVideoTaskInfo(const Model::QueryVideoTaskInfoRequest &request)const;
+			void queryVideoTaskInfoAsync(const Model::QueryVideoTaskInfoRequest& request, const QueryVideoTaskInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryVideoTaskInfoOutcomeCallable queryVideoTaskInfoCallable(const Model::QueryVideoTaskInfoRequest& 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;

avatar/include/alibabacloud/avatar/model/GetVideoTaskInfoResult.h

@@ -38,6 +38,7 @@ namespace AlibabaCloud
 					{
 						std::string alphaUrl;
 						int videoDuration;
+						std::string previewPic;
 						std::string failCode;
 						std::string subtitlesUrl;
 						std::string wordSubtitlesUrl;

avatar/include/alibabacloud/avatar/model/QueryAvatarListResult.h

@@ -54,6 +54,7 @@ namespace AlibabaCloud
 							std::vector<OnlineItem> online;
 						};
 						std::string description;
+						std::string makeStage;
 						SupportedResolutions supportedResolutions;
 						std::string portrait;
 						std::string avatarType;

avatar/include/alibabacloud/avatar/model/QueryAvatarResult.h

@@ -52,12 +52,14 @@ namespace AlibabaCloud
 						std::vector<OnlineItem> online;
 					};
 					std::string description;
+					std::string makeStage;
 					SupportedResolutions supportedResolutions;
 					std::string portrait;
 					std::string modelType;
 					std::string avatarType;
 					std::string makeStatus;
 					std::string image;
+					std::string allLocateImages;
 					std::string name;
 					std::string makeFailReason;
 				};

avatar/include/alibabacloud/avatar/model/QueryVideoTaskInfoRequest.h

@@ -0,0 +1,69 @@
+/*
+ * 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_QUERYVIDEOTASKINFOREQUEST_H_
+#define ALIBABACLOUD_AVATAR_MODEL_QUERYVIDEOTASKINFOREQUEST_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 QueryVideoTaskInfoRequest : public RpcServiceRequest {
+public:
+	struct App {
+		std::string appId;
+	};
+	QueryVideoTaskInfoRequest();
+	~QueryVideoTaskInfoRequest();
+	App getApp() const;
+	void setApp(const App &app);
+	std::string getTitle() const;
+	void setTitle(const std::string &title);
+	int getType() const;
+	void setType(int type);
+	std::string getOrderById() const;
+	void setOrderById(const std::string &orderById);
+	int getPageNo() const;
+	void setPageNo(int pageNo);
+	long getTenantId() const;
+	void setTenantId(long tenantId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getTaskUuid() const;
+	void setTaskUuid(const std::string &taskUuid);
+	int getStatus() const;
+	void setStatus(int status);
+
+private:
+	App app_;
+	std::string title_;
+	int type_;
+	std::string orderById_;
+	int pageNo_;
+	long tenantId_;
+	int pageSize_;
+	std::string taskUuid_;
+	int status_;
+};
+} // namespace Model
+} // namespace Avatar
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AVATAR_MODEL_QUERYVIDEOTASKINFOREQUEST_H_

avatar/include/alibabacloud/avatar/model/QueryVideoTaskInfoResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_AVATAR_MODEL_QUERYVIDEOTASKINFORESULT_H_
+#define ALIBABACLOUD_AVATAR_MODEL_QUERYVIDEOTASKINFORESULT_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 QueryVideoTaskInfoResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct ListItem
+					{
+						struct TaskResult
+						{
+							std::string alphaUrl;
+							int videoDuration;
+							std::string previewPic;
+							std::string failCode;
+							std::string subtitlesUrl;
+							std::string wordSubtitlesUrl;
+							std::string failReason;
+							std::string videoUrl;
+						};
+						int status;
+						int type;
+						std::string taskUuid;
+						TaskResult taskResult;
+						std::string title;
+					};
+					long totalCount;
+					int pageSize;
+					std::vector<ListItem> list;
+					int pageNo;
+				};
+
+
+				QueryVideoTaskInfoResult();
+				explicit QueryVideoTaskInfoResult(const std::string &payload);
+				~QueryVideoTaskInfoResult();
+				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_QUERYVIDEOTASKINFORESULT_H_

avatar/src/AvatarClient.cc

@@ -447,6 +447,42 @@ AvatarClient::QueryTimedResetOperateStatusOutcomeCallable AvatarClient::queryTim
 	return task->get_future();
 }
 
+AvatarClient::QueryVideoTaskInfoOutcome AvatarClient::queryVideoTaskInfo(const QueryVideoTaskInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryVideoTaskInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryVideoTaskInfoOutcome(QueryVideoTaskInfoResult(outcome.result()));
+	else
+		return QueryVideoTaskInfoOutcome(outcome.error());
+}
+
+void AvatarClient::queryVideoTaskInfoAsync(const QueryVideoTaskInfoRequest& request, const QueryVideoTaskInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryVideoTaskInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AvatarClient::QueryVideoTaskInfoOutcomeCallable AvatarClient::queryVideoTaskInfoCallable(const QueryVideoTaskInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryVideoTaskInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->queryVideoTaskInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AvatarClient::SendCommandOutcome AvatarClient::sendCommand(const SendCommandRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

avatar/src/model/GetVideoTaskInfoResult.cc

@@ -63,6 +63,8 @@ void GetVideoTaskInfoResult::parse(const std::string &payload)
 		data_.taskResult.videoDuration = std::stoi(taskResultNode["VideoDuration"].asString());
 	if(!taskResultNode["AlphaUrl"].isNull())
 		data_.taskResult.alphaUrl = taskResultNode["AlphaUrl"].asString();
+	if(!taskResultNode["PreviewPic"].isNull())
+		data_.taskResult.previewPic = taskResultNode["PreviewPic"].asString();
 	if(!value["Code"].isNull())
 		code_ = value["Code"].asString();
 	if(!value["Message"].isNull())

avatar/src/model/QueryAvatarListResult.cc

@@ -70,6 +70,8 @@ void QueryAvatarListResult::parse(const std::string &payload)
 			listItemObject.makeStatus = dataNodeListlistItem["MakeStatus"].asString();
 		if(!dataNodeListlistItem["MakeFailReason"].isNull())
 			listItemObject.makeFailReason = dataNodeListlistItem["MakeFailReason"].asString();
+		if(!dataNodeListlistItem["MakeStage"].isNull())
+			listItemObject.makeStage = dataNodeListlistItem["MakeStage"].asString();
 		auto supportedResolutionsNode = value["SupportedResolutions"];
 		auto allOfflineNode = supportedResolutionsNode["Offline"]["offlineItem"];
 		for (auto supportedResolutionsNodeOfflineofflineItem : allOfflineNode)

avatar/src/model/QueryAvatarResult.cc

@@ -48,6 +48,8 @@ void QueryAvatarResult::parse(const std::string &payload)
 		data_.portrait = dataNode["Portrait"].asString();
 	if(!dataNode["Image"].isNull())
 		data_.image = dataNode["Image"].asString();
+	if(!dataNode["AllLocateImages"].isNull())
+		data_.allLocateImages = dataNode["AllLocateImages"].asString();
 	if(!dataNode["ModelType"].isNull())
 		data_.modelType = dataNode["ModelType"].asString();
 	if(!dataNode["AvatarType"].isNull())
@@ -56,6 +58,8 @@ void QueryAvatarResult::parse(const std::string &payload)
 		data_.makeStatus = dataNode["MakeStatus"].asString();
 	if(!dataNode["MakeFailReason"].isNull())
 		data_.makeFailReason = dataNode["MakeFailReason"].asString();
+	if(!dataNode["MakeStage"].isNull())
+		data_.makeStage = dataNode["MakeStage"].asString();
 	auto supportedResolutionsNode = dataNode["SupportedResolutions"];
 	auto allOfflineNode = supportedResolutionsNode["Offline"]["offlineItem"];
 	for (auto supportedResolutionsNodeOfflineofflineItem : allOfflineNode)

avatar/src/model/QueryVideoTaskInfoRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * 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/QueryVideoTaskInfoRequest.h>
+
+using AlibabaCloud::Avatar::Model::QueryVideoTaskInfoRequest;
+
+QueryVideoTaskInfoRequest::QueryVideoTaskInfoRequest()
+    : RpcServiceRequest("avatar", "2022-01-30", "QueryVideoTaskInfo") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+QueryVideoTaskInfoRequest::~QueryVideoTaskInfoRequest() {}
+
+QueryVideoTaskInfoRequest::App QueryVideoTaskInfoRequest::getApp() const {
+  return app_;
+}
+
+void QueryVideoTaskInfoRequest::setApp(const QueryVideoTaskInfoRequest::App &app) {
+  app_ = app;
+  setParameter(std::string("App") + ".AppId", app.appId);
+}
+
+std::string QueryVideoTaskInfoRequest::getTitle() const {
+  return title_;
+}
+
+void QueryVideoTaskInfoRequest::setTitle(const std::string &title) {
+  title_ = title;
+  setParameter(std::string("Title"), title);
+}
+
+int QueryVideoTaskInfoRequest::getType() const {
+  return type_;
+}
+
+void QueryVideoTaskInfoRequest::setType(int type) {
+  type_ = type;
+  setParameter(std::string("Type"), std::to_string(type));
+}
+
+std::string QueryVideoTaskInfoRequest::getOrderById() const {
+  return orderById_;
+}
+
+void QueryVideoTaskInfoRequest::setOrderById(const std::string &orderById) {
+  orderById_ = orderById;
+  setParameter(std::string("OrderById"), orderById);
+}
+
+int QueryVideoTaskInfoRequest::getPageNo() const {
+  return pageNo_;
+}
+
+void QueryVideoTaskInfoRequest::setPageNo(int pageNo) {
+  pageNo_ = pageNo;
+  setParameter(std::string("PageNo"), std::to_string(pageNo));
+}
+
+long QueryVideoTaskInfoRequest::getTenantId() const {
+  return tenantId_;
+}
+
+void QueryVideoTaskInfoRequest::setTenantId(long tenantId) {
+  tenantId_ = tenantId;
+  setParameter(std::string("TenantId"), std::to_string(tenantId));
+}
+
+int QueryVideoTaskInfoRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void QueryVideoTaskInfoRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string QueryVideoTaskInfoRequest::getTaskUuid() const {
+  return taskUuid_;
+}
+
+void QueryVideoTaskInfoRequest::setTaskUuid(const std::string &taskUuid) {
+  taskUuid_ = taskUuid;
+  setParameter(std::string("TaskUuid"), taskUuid);
+}
+
+int QueryVideoTaskInfoRequest::getStatus() const {
+  return status_;
+}
+
+void QueryVideoTaskInfoRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
+}
+

avatar/src/model/QueryVideoTaskInfoResult.cc

@@ -0,0 +1,108 @@
+/*
+ * 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/QueryVideoTaskInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Avatar;
+using namespace AlibabaCloud::Avatar::Model;
+
+QueryVideoTaskInfoResult::QueryVideoTaskInfoResult() :
+	ServiceResult()
+{}
+
+QueryVideoTaskInfoResult::QueryVideoTaskInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+QueryVideoTaskInfoResult::~QueryVideoTaskInfoResult()
+{}
+
+void QueryVideoTaskInfoResult::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["PageNo"].isNull())
+		data_.pageNo = std::stoi(dataNode["PageNo"].asString());
+	if(!dataNode["PageSize"].isNull())
+		data_.pageSize = std::stoi(dataNode["PageSize"].asString());
+	if(!dataNode["TotalCount"].isNull())
+		data_.totalCount = std::stol(dataNode["TotalCount"].asString());
+	auto allListNode = dataNode["List"]["listItem"];
+	for (auto dataNodeListlistItem : allListNode)
+	{
+		Data::ListItem listItemObject;
+		if(!dataNodeListlistItem["TaskUuid"].isNull())
+			listItemObject.taskUuid = dataNodeListlistItem["TaskUuid"].asString();
+		if(!dataNodeListlistItem["Title"].isNull())
+			listItemObject.title = dataNodeListlistItem["Title"].asString();
+		if(!dataNodeListlistItem["Type"].isNull())
+			listItemObject.type = std::stoi(dataNodeListlistItem["Type"].asString());
+		if(!dataNodeListlistItem["Status"].isNull())
+			listItemObject.status = std::stoi(dataNodeListlistItem["Status"].asString());
+		auto taskResultNode = value["TaskResult"];
+		if(!taskResultNode["VideoUrl"].isNull())
+			listItemObject.taskResult.videoUrl = taskResultNode["VideoUrl"].asString();
+		if(!taskResultNode["SubtitlesUrl"].isNull())
+			listItemObject.taskResult.subtitlesUrl = taskResultNode["SubtitlesUrl"].asString();
+		if(!taskResultNode["WordSubtitlesUrl"].isNull())
+			listItemObject.taskResult.wordSubtitlesUrl = taskResultNode["WordSubtitlesUrl"].asString();
+		if(!taskResultNode["VideoDuration"].isNull())
+			listItemObject.taskResult.videoDuration = std::stoi(taskResultNode["VideoDuration"].asString());
+		if(!taskResultNode["FailReason"].isNull())
+			listItemObject.taskResult.failReason = taskResultNode["FailReason"].asString();
+		if(!taskResultNode["FailCode"].isNull())
+			listItemObject.taskResult.failCode = taskResultNode["FailCode"].asString();
+		if(!taskResultNode["AlphaUrl"].isNull())
+			listItemObject.taskResult.alphaUrl = taskResultNode["AlphaUrl"].asString();
+		if(!taskResultNode["PreviewPic"].isNull())
+			listItemObject.taskResult.previewPic = taskResultNode["PreviewPic"].asString();
+		data_.list.push_back(listItemObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string QueryVideoTaskInfoResult::getMessage()const
+{
+	return message_;
+}
+
+QueryVideoTaskInfoResult::Data QueryVideoTaskInfoResult::getData()const
+{
+	return data_;
+}
+
+std::string QueryVideoTaskInfoResult::getCode()const
+{
+	return code_;
+}
+
+bool QueryVideoTaskInfoResult::getSuccess()const
+{
+	return success_;
+}
+

cbn/include/alibabacloud/cbn/model/DescribeChildInstanceRegionsRequest.h

@@ -44,6 +44,8 @@ public:
 	void setVersion(const std::string &version);
 	long getChildInstanceOwnerId() const;
 	void setChildInstanceOwnerId(long childInstanceOwnerId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
 
 private:
 	long resourceOwnerId_;
@@ -53,6 +55,7 @@ private:
 	long ownerId_;
 	std::string version_;
 	long childInstanceOwnerId_;
+	std::string acceptLanguage_;
 };
 } // namespace Model
 } // namespace Cbn

cbn/src/model/DescribeChildInstanceRegionsRequest.cc

@@ -88,3 +88,12 @@ void DescribeChildInstanceRegionsRequest::setChildInstanceOwnerId(long childInst
   setParameter(std::string("ChildInstanceOwnerId"), std::to_string(childInstanceOwnerId));
 }
 
+std::string DescribeChildInstanceRegionsRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void DescribeChildInstanceRegionsRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

config/CMakeLists.txt

@@ -79,6 +79,8 @@ set(config_public_header_model
 	include/alibabacloud/config/model/DeleteConfigRulesResult.h
 	include/alibabacloud/config/model/DeleteRemediationsRequest.h
 	include/alibabacloud/config/model/DeleteRemediationsResult.h
+	include/alibabacloud/config/model/DescribeRemediationRequest.h
+	include/alibabacloud/config/model/DescribeRemediationResult.h
 	include/alibabacloud/config/model/DetachAggregateConfigRuleToCompliancePackRequest.h
 	include/alibabacloud/config/model/DetachAggregateConfigRuleToCompliancePackResult.h
 	include/alibabacloud/config/model/DetachConfigRuleToCompliancePackRequest.h
@@ -358,6 +360,8 @@ set(config_src
 	src/model/DeleteConfigRulesResult.cc
 	src/model/DeleteRemediationsRequest.cc
 	src/model/DeleteRemediationsResult.cc
+	src/model/DescribeRemediationRequest.cc
+	src/model/DescribeRemediationResult.cc
 	src/model/DetachAggregateConfigRuleToCompliancePackRequest.cc
 	src/model/DetachAggregateConfigRuleToCompliancePackResult.cc
 	src/model/DetachConfigRuleToCompliancePackRequest.cc

config/include/alibabacloud/config/ConfigClient.h

@@ -80,6 +80,8 @@
 #include "model/DeleteConfigRulesResult.h"
 #include "model/DeleteRemediationsRequest.h"
 #include "model/DeleteRemediationsResult.h"
+#include "model/DescribeRemediationRequest.h"
+#include "model/DescribeRemediationResult.h"
 #include "model/DetachAggregateConfigRuleToCompliancePackRequest.h"
 #include "model/DetachAggregateConfigRuleToCompliancePackResult.h"
 #include "model/DetachConfigRuleToCompliancePackRequest.h"
@@ -394,6 +396,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteRemediationsResult> DeleteRemediationsOutcome;
 			typedef std::future<DeleteRemediationsOutcome> DeleteRemediationsOutcomeCallable;
 			typedef std::function<void(const ConfigClient*, const Model::DeleteRemediationsRequest&, const DeleteRemediationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteRemediationsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRemediationResult> DescribeRemediationOutcome;
+			typedef std::future<DescribeRemediationOutcome> DescribeRemediationOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DescribeRemediationRequest&, const DescribeRemediationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRemediationAsyncHandler;
 			typedef Outcome<Error, Model::DetachAggregateConfigRuleToCompliancePackResult> DetachAggregateConfigRuleToCompliancePackOutcome;
 			typedef std::future<DetachAggregateConfigRuleToCompliancePackOutcome> DetachAggregateConfigRuleToCompliancePackOutcomeCallable;
 			typedef std::function<void(const ConfigClient*, const Model::DetachAggregateConfigRuleToCompliancePackRequest&, const DetachAggregateConfigRuleToCompliancePackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachAggregateConfigRuleToCompliancePackAsyncHandler;
@@ -813,6 +818,9 @@ namespace AlibabaCloud
 			DeleteRemediationsOutcome deleteRemediations(const Model::DeleteRemediationsRequest &request)const;
 			void deleteRemediationsAsync(const Model::DeleteRemediationsRequest& request, const DeleteRemediationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteRemediationsOutcomeCallable deleteRemediationsCallable(const Model::DeleteRemediationsRequest& request) const;
+			DescribeRemediationOutcome describeRemediation(const Model::DescribeRemediationRequest &request)const;
+			void describeRemediationAsync(const Model::DescribeRemediationRequest& request, const DescribeRemediationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRemediationOutcomeCallable describeRemediationCallable(const Model::DescribeRemediationRequest& request) const;
 			DetachAggregateConfigRuleToCompliancePackOutcome detachAggregateConfigRuleToCompliancePack(const Model::DetachAggregateConfigRuleToCompliancePackRequest &request)const;
 			void detachAggregateConfigRuleToCompliancePackAsync(const Model::DetachAggregateConfigRuleToCompliancePackRequest& request, const DetachAggregateConfigRuleToCompliancePackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetachAggregateConfigRuleToCompliancePackOutcomeCallable detachAggregateConfigRuleToCompliancePackCallable(const Model::DetachAggregateConfigRuleToCompliancePackRequest& request) const;

config/include/alibabacloud/config/model/CreateAggregateConfigRuleRequest.h

@@ -70,6 +70,8 @@ public:
 	void setFolderIdsScope(const std::string &folderIdsScope);
 	std::string getExcludeResourceIdsScope() const;
 	void setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope);
+	std::string getConditions() const;
+	void setConditions(const std::string &conditions);
 
 private:
 	std::string tagKeyScope_;
@@ -92,6 +94,7 @@ private:
 	std::string maximumExecutionFrequency_;
 	std::string folderIdsScope_;
 	std::string excludeResourceIdsScope_;
+	std::string conditions_;
 };
 } // namespace Model
 } // namespace Config

config/include/alibabacloud/config/model/CreateConfigRuleRequest.h

@@ -62,6 +62,8 @@ public:
 	void setMaximumExecutionFrequency(const std::string &maximumExecutionFrequency);
 	std::string getExcludeResourceIdsScope() const;
 	void setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope);
+	std::string getConditions() const;
+	void setConditions(const std::string &conditions);
 
 private:
 	std::string tagKeyScope_;
@@ -80,6 +82,7 @@ private:
 	std::string tagKeyLogicScope_;
 	std::string maximumExecutionFrequency_;
 	std::string excludeResourceIdsScope_;
+	std::string conditions_;
 };
 } // namespace Model
 } // namespace Config

config/include/alibabacloud/config/model/DescribeRemediationRequest.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_CONFIG_MODEL_DESCRIBEREMEDIATIONREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DESCRIBEREMEDIATIONREQUEST_H_
+
+#include <alibabacloud/config/ConfigExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Config {
+namespace Model {
+class ALIBABACLOUD_CONFIG_EXPORT DescribeRemediationRequest : public RpcServiceRequest {
+public:
+	DescribeRemediationRequest();
+	~DescribeRemediationRequest();
+	std::string getConfigRuleId() const;
+	void setConfigRuleId(const std::string &configRuleId);
+	std::string getRemediationId() const;
+	void setRemediationId(const std::string &remediationId);
+
+private:
+	std::string configRuleId_;
+	std::string remediationId_;
+};
+} // namespace Model
+} // namespace Config
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DESCRIBEREMEDIATIONREQUEST_H_

config/include/alibabacloud/config/model/DescribeRemediationResult.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CONFIG_MODEL_DESCRIBEREMEDIATIONRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DESCRIBEREMEDIATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT DescribeRemediationResult : public ServiceResult
+			{
+			public:
+				struct Remediation
+				{
+					std::string lastSuccessfulInvocationType;
+					std::string configRuleId;
+					std::string remediationTemplateId;
+					long accountId;
+					std::string remediationSourceType;
+					long lastSuccessfulInvocationTime;
+					std::string invokeType;
+					std::string remediationOriginParams;
+					std::string remediationId;
+					std::string lastSuccessfulInvocationId;
+					std::string remediationDynamicParams;
+					std::string remediationType;
+				};
+
+
+				DescribeRemediationResult();
+				explicit DescribeRemediationResult(const std::string &payload);
+				~DescribeRemediationResult();
+				Remediation getRemediation()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Remediation remediation_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DESCRIBEREMEDIATIONRESULT_H_

config/include/alibabacloud/config/model/GetAggregateConfigRuleResult.h

@@ -46,6 +46,7 @@ namespace AlibabaCloud
 						std::string identifier;
 						std::vector<std::string> sourceConditions;
 						std::vector<SourceDetailsItem> sourceDetails;
+						std::string conditions;
 					};
 					struct ManagedRule
 					{

config/include/alibabacloud/config/model/GetConfigRuleResult.h

@@ -46,6 +46,7 @@ namespace AlibabaCloud
 						std::string identifier;
 						std::vector<std::string> sourceConditions;
 						std::vector<SourceDetailsItem> sourceDetails;
+						std::string conditions;
 					};
 					struct ManagedRule
 					{

config/include/alibabacloud/config/model/ListAggregateResourceRelationsResult.h

@@ -37,7 +37,7 @@ namespace AlibabaCloud
 					struct ResourceRelationListItem
 					{
 						std::string targetResourceType;
-						int accountId;
+						long accountId;
 						std::string targetResourceId;
 						std::string relationType;
 						std::string sourceResourceRegionId;

config/include/alibabacloud/config/model/UpdateAggregateConfigRuleRequest.h

@@ -68,6 +68,8 @@ public:
 	void setFolderIdsScope(const std::string &folderIdsScope);
 	std::string getExcludeResourceIdsScope() const;
 	void setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope);
+	std::string getConditions() const;
+	void setConditions(const std::string &conditions);
 
 private:
 	std::string configRuleId_;
@@ -89,6 +91,7 @@ private:
 	std::string maximumExecutionFrequency_;
 	std::string folderIdsScope_;
 	std::string excludeResourceIdsScope_;
+	std::string conditions_;
 };
 } // namespace Model
 } // namespace Config

config/include/alibabacloud/config/model/UpdateConfigRuleRequest.h

@@ -60,6 +60,8 @@ public:
 	void setMaximumExecutionFrequency(const std::string &maximumExecutionFrequency);
 	std::string getExcludeResourceIdsScope() const;
 	void setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope);
+	std::string getConditions() const;
+	void setConditions(const std::string &conditions);
 
 private:
 	std::string configRuleId_;
@@ -77,6 +79,7 @@ private:
 	std::string tagKeyLogicScope_;
 	std::string maximumExecutionFrequency_;
 	std::string excludeResourceIdsScope_;
+	std::string conditions_;
 };
 } // namespace Model
 } // namespace Config

config/src/ConfigClient.cc

@@ -1095,6 +1095,42 @@ ConfigClient::DeleteRemediationsOutcomeCallable ConfigClient::deleteRemediations
 	return task->get_future();
 }
 
+ConfigClient::DescribeRemediationOutcome ConfigClient::describeRemediation(const DescribeRemediationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRemediationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRemediationOutcome(DescribeRemediationResult(outcome.result()));
+	else
+		return DescribeRemediationOutcome(outcome.error());
+}
+
+void ConfigClient::describeRemediationAsync(const DescribeRemediationRequest& request, const DescribeRemediationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRemediation(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::DescribeRemediationOutcomeCallable ConfigClient::describeRemediationCallable(const DescribeRemediationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRemediationOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRemediation(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ConfigClient::DetachAggregateConfigRuleToCompliancePackOutcome ConfigClient::detachAggregateConfigRuleToCompliancePack(const DetachAggregateConfigRuleToCompliancePackRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

config/src/model/CreateAggregateConfigRuleRequest.cc

@@ -207,3 +207,12 @@ void CreateAggregateConfigRuleRequest::setExcludeResourceIdsScope(const std::str
   setBodyParameter(std::string("ExcludeResourceIdsScope"), excludeResourceIdsScope);
 }
 
+std::string CreateAggregateConfigRuleRequest::getConditions() const {
+  return conditions_;
+}
+
+void CreateAggregateConfigRuleRequest::setConditions(const std::string &conditions) {
+  conditions_ = conditions;
+  setBodyParameter(std::string("Conditions"), conditions);
+}
+

config/src/model/CreateConfigRuleRequest.cc

@@ -171,3 +171,12 @@ void CreateConfigRuleRequest::setExcludeResourceIdsScope(const std::string &excl
   setBodyParameter(std::string("ExcludeResourceIdsScope"), excludeResourceIdsScope);
 }
 
+std::string CreateConfigRuleRequest::getConditions() const {
+  return conditions_;
+}
+
+void CreateConfigRuleRequest::setConditions(const std::string &conditions) {
+  conditions_ = conditions;
+  setBodyParameter(std::string("Conditions"), conditions);
+}
+

config/src/model/DescribeRemediationRequest.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/config/model/DescribeRemediationRequest.h>
+
+using AlibabaCloud::Config::Model::DescribeRemediationRequest;
+
+DescribeRemediationRequest::DescribeRemediationRequest()
+    : RpcServiceRequest("config", "2020-09-07", "DescribeRemediation") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeRemediationRequest::~DescribeRemediationRequest() {}
+
+std::string DescribeRemediationRequest::getConfigRuleId() const {
+  return configRuleId_;
+}
+
+void DescribeRemediationRequest::setConfigRuleId(const std::string &configRuleId) {
+  configRuleId_ = configRuleId;
+  setParameter(std::string("ConfigRuleId"), configRuleId);
+}
+
+std::string DescribeRemediationRequest::getRemediationId() const {
+  return remediationId_;
+}
+
+void DescribeRemediationRequest::setRemediationId(const std::string &remediationId) {
+  remediationId_ = remediationId;
+  setParameter(std::string("RemediationId"), remediationId);
+}
+

config/src/model/DescribeRemediationResult.cc

@@ -0,0 +1,74 @@
+/*
+ * 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/config/model/DescribeRemediationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+DescribeRemediationResult::DescribeRemediationResult() :
+	ServiceResult()
+{}
+
+DescribeRemediationResult::DescribeRemediationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeRemediationResult::~DescribeRemediationResult()
+{}
+
+void DescribeRemediationResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto remediationNode = value["Remediation"];
+	if(!remediationNode["LastSuccessfulInvocationType"].isNull())
+		remediation_.lastSuccessfulInvocationType = remediationNode["LastSuccessfulInvocationType"].asString();
+	if(!remediationNode["RemediationTemplateId"].isNull())
+		remediation_.remediationTemplateId = remediationNode["RemediationTemplateId"].asString();
+	if(!remediationNode["RemediationDynamicParams"].isNull())
+		remediation_.remediationDynamicParams = remediationNode["RemediationDynamicParams"].asString();
+	if(!remediationNode["RemediationOriginParams"].isNull())
+		remediation_.remediationOriginParams = remediationNode["RemediationOriginParams"].asString();
+	if(!remediationNode["RemediationId"].isNull())
+		remediation_.remediationId = remediationNode["RemediationId"].asString();
+	if(!remediationNode["RemediationSourceType"].isNull())
+		remediation_.remediationSourceType = remediationNode["RemediationSourceType"].asString();
+	if(!remediationNode["RemediationType"].isNull())
+		remediation_.remediationType = remediationNode["RemediationType"].asString();
+	if(!remediationNode["LastSuccessfulInvocationId"].isNull())
+		remediation_.lastSuccessfulInvocationId = remediationNode["LastSuccessfulInvocationId"].asString();
+	if(!remediationNode["AccountId"].isNull())
+		remediation_.accountId = std::stol(remediationNode["AccountId"].asString());
+	if(!remediationNode["InvokeType"].isNull())
+		remediation_.invokeType = remediationNode["InvokeType"].asString();
+	if(!remediationNode["ConfigRuleId"].isNull())
+		remediation_.configRuleId = remediationNode["ConfigRuleId"].asString();
+	if(!remediationNode["LastSuccessfulInvocationTime"].isNull())
+		remediation_.lastSuccessfulInvocationTime = std::stol(remediationNode["LastSuccessfulInvocationTime"].asString());
+
+}
+
+DescribeRemediationResult::Remediation DescribeRemediationResult::getRemediation()const
+{
+	return remediation_;
+}
+

config/src/model/GetAggregateConfigRuleResult.cc

@@ -91,6 +91,8 @@ void GetAggregateConfigRuleResult::parse(const std::string &payload)
 		configRule_.source.owner = sourceNode["Owner"].asString();
 	if(!sourceNode["Identifier"].isNull())
 		configRule_.source.identifier = sourceNode["Identifier"].asString();
+	if(!sourceNode["Conditions"].isNull())
+		configRule_.source.conditions = sourceNode["Conditions"].asString();
 	auto allSourceDetailsNode = sourceNode["SourceDetails"]["SourceDetailsItem"];
 	for (auto sourceNodeSourceDetailsSourceDetailsItem : allSourceDetailsNode)
 	{

config/src/model/GetConfigRuleResult.cc

@@ -85,19 +85,21 @@ void GetConfigRuleResult::parse(const std::string &payload)
 		configRule_.source.owner = sourceNode["Owner"].asString();
 	if(!sourceNode["Identifier"].isNull())
 		configRule_.source.identifier = sourceNode["Identifier"].asString();
-	auto allSourceDetailsNode = sourceNode["SourceDetails"]["SourceDetailsItem"];
-	for (auto sourceNodeSourceDetailsSourceDetailsItem : allSourceDetailsNode)
+	if(!sourceNode["Conditions"].isNull())
+		configRule_.source.conditions = sourceNode["Conditions"].asString();
+	auto allSourceDetailsNode = sourceNode["SourceDetails"]["sourceDetailsItem"];
+	for (auto sourceNodeSourceDetailssourceDetailsItem : allSourceDetailsNode)
 	{
 		ConfigRule::Source::SourceDetailsItem sourceDetailsItemObject;
-		if(!sourceNodeSourceDetailsSourceDetailsItem["MessageType"].isNull())
-			sourceDetailsItemObject.messageType = sourceNodeSourceDetailsSourceDetailsItem["MessageType"].asString();
-		if(!sourceNodeSourceDetailsSourceDetailsItem["EventSource"].isNull())
-			sourceDetailsItemObject.eventSource = sourceNodeSourceDetailsSourceDetailsItem["EventSource"].asString();
-		if(!sourceNodeSourceDetailsSourceDetailsItem["MaximumExecutionFrequency"].isNull())
-			sourceDetailsItemObject.maximumExecutionFrequency = sourceNodeSourceDetailsSourceDetailsItem["MaximumExecutionFrequency"].asString();
+		if(!sourceNodeSourceDetailssourceDetailsItem["MessageType"].isNull())
+			sourceDetailsItemObject.messageType = sourceNodeSourceDetailssourceDetailsItem["MessageType"].asString();
+		if(!sourceNodeSourceDetailssourceDetailsItem["EventSource"].isNull())
+			sourceDetailsItemObject.eventSource = sourceNodeSourceDetailssourceDetailsItem["EventSource"].asString();
+		if(!sourceNodeSourceDetailssourceDetailsItem["MaximumExecutionFrequency"].isNull())
+			sourceDetailsItemObject.maximumExecutionFrequency = sourceNodeSourceDetailssourceDetailsItem["MaximumExecutionFrequency"].asString();
 		configRule_.source.sourceDetails.push_back(sourceDetailsItemObject);
 	}
-		auto allSourceConditions = sourceNode["SourceConditions"]["SourceConditions"];
+		auto allSourceConditions = sourceNode["SourceConditions"]["sourceConditions"];
 		for (auto value : allSourceConditions)
 			configRule_.source.sourceConditions.push_back(value.asString());
 	auto managedRuleNode = configRuleNode["ManagedRule"];
@@ -113,19 +115,19 @@ void GetConfigRuleResult::parse(const std::string &payload)
 		configRule_.managedRule.managedRuleName = managedRuleNode["ManagedRuleName"].asString();
 	if(!managedRuleNode["CompulsoryInputParameterDetails"].isNull())
 		configRule_.managedRule.compulsoryInputParameterDetails = managedRuleNode["CompulsoryInputParameterDetails"].asString();
-	auto allSourceDetails1Node = managedRuleNode["SourceDetails"]["SourceDetailsItem"];
-	for (auto managedRuleNodeSourceDetailsSourceDetailsItem : allSourceDetails1Node)
+	auto allSourceDetails1Node = managedRuleNode["SourceDetails"]["sourceDetailsItem"];
+	for (auto managedRuleNodeSourceDetailssourceDetailsItem : allSourceDetails1Node)
 	{
 		ConfigRule::ManagedRule::SourceDetailsItem2 sourceDetailsItem2Object;
-		if(!managedRuleNodeSourceDetailsSourceDetailsItem["MessageType"].isNull())
-			sourceDetailsItem2Object.messageType = managedRuleNodeSourceDetailsSourceDetailsItem["MessageType"].asString();
-		if(!managedRuleNodeSourceDetailsSourceDetailsItem["EventSource"].isNull())
-			sourceDetailsItem2Object.eventSource = managedRuleNodeSourceDetailsSourceDetailsItem["EventSource"].asString();
-		if(!managedRuleNodeSourceDetailsSourceDetailsItem["MaximumExecutionFrequency"].isNull())
-			sourceDetailsItem2Object.maximumExecutionFrequency = managedRuleNodeSourceDetailsSourceDetailsItem["MaximumExecutionFrequency"].asString();
+		if(!managedRuleNodeSourceDetailssourceDetailsItem["MessageType"].isNull())
+			sourceDetailsItem2Object.messageType = managedRuleNodeSourceDetailssourceDetailsItem["MessageType"].asString();
+		if(!managedRuleNodeSourceDetailssourceDetailsItem["EventSource"].isNull())
+			sourceDetailsItem2Object.eventSource = managedRuleNodeSourceDetailssourceDetailsItem["EventSource"].asString();
+		if(!managedRuleNodeSourceDetailssourceDetailsItem["MaximumExecutionFrequency"].isNull())
+			sourceDetailsItem2Object.maximumExecutionFrequency = managedRuleNodeSourceDetailssourceDetailsItem["MaximumExecutionFrequency"].asString();
 		configRule_.managedRule.sourceDetails1.push_back(sourceDetailsItem2Object);
 	}
-		auto allLabels = managedRuleNode["Labels"]["Labels"];
+		auto allLabels = managedRuleNode["Labels"]["labels"];
 		for (auto value : allLabels)
 			configRule_.managedRule.labels.push_back(value.asString());
 	auto createByNode = configRuleNode["CreateBy"];
@@ -161,7 +163,7 @@ void GetConfigRuleResult::parse(const std::string &payload)
 	if(!configRuleEvaluationStatusNode["LastFailedInvocationTimestamp"].isNull())
 		configRule_.configRuleEvaluationStatus.lastFailedInvocationTimestamp = std::stol(configRuleEvaluationStatusNode["LastFailedInvocationTimestamp"].asString());
 	auto scopeNode = configRuleNode["Scope"];
-		auto allComplianceResourceTypes = scopeNode["ComplianceResourceTypes"]["ComplianceResourceTypes"];
+		auto allComplianceResourceTypes = scopeNode["ComplianceResourceTypes"]["complianceResourceTypes"];
 		for (auto value : allComplianceResourceTypes)
 			configRule_.scope.complianceResourceTypes.push_back(value.asString());
 	auto complianceNode = configRuleNode["Compliance"];

config/src/model/ListAggregateResourceRelationsResult.cc

@@ -51,7 +51,7 @@ void ListAggregateResourceRelationsResult::parse(const std::string &payload)
 	{
 		ResourceRelations::ResourceRelationListItem resourceRelationListItemObject;
 		if(!resourceRelationsNodeResourceRelationListResourceRelationListItem["AccountId"].isNull())
-			resourceRelationListItemObject.accountId = std::stoi(resourceRelationsNodeResourceRelationListResourceRelationListItem["AccountId"].asString());
+			resourceRelationListItemObject.accountId = std::stol(resourceRelationsNodeResourceRelationListResourceRelationListItem["AccountId"].asString());
 		if(!resourceRelationsNodeResourceRelationListResourceRelationListItem["SourceResourceType"].isNull())
 			resourceRelationListItemObject.sourceResourceType = resourceRelationsNodeResourceRelationListResourceRelationListItem["SourceResourceType"].asString();
 		if(!resourceRelationsNodeResourceRelationListResourceRelationListItem["SourceResourceRegionId"].isNull())

config/src/model/UpdateAggregateConfigRuleRequest.cc

@@ -198,3 +198,12 @@ void UpdateAggregateConfigRuleRequest::setExcludeResourceIdsScope(const std::str
   setBodyParameter(std::string("ExcludeResourceIdsScope"), excludeResourceIdsScope);
 }
 
+std::string UpdateAggregateConfigRuleRequest::getConditions() const {
+  return conditions_;
+}
+
+void UpdateAggregateConfigRuleRequest::setConditions(const std::string &conditions) {
+  conditions_ = conditions;
+  setBodyParameter(std::string("Conditions"), conditions);
+}
+

config/src/model/UpdateConfigRuleRequest.cc

@@ -162,3 +162,12 @@ void UpdateConfigRuleRequest::setExcludeResourceIdsScope(const std::string &excl
   setBodyParameter(std::string("ExcludeResourceIdsScope"), excludeResourceIdsScope);
 }
 
+std::string UpdateConfigRuleRequest::getConditions() const {
+  return conditions_;
+}
+
+void UpdateConfigRuleRequest::setConditions(const std::string &conditions) {
+  conditions_ = conditions;
+  setBodyParameter(std::string("Conditions"), conditions);
+}
+

core/CMakeLists.txt

@@ -183,6 +183,15 @@ if(CMAKE_HOST_WIN32)
 	target_compile_definitions(core
 		PRIVATE CURL_STATICLIB
 			_CRT_SECURE_NO_WARNINGS)
+elseif(CMAKE_HOST_APPLE)
+	MESSAGE(STATUS "core: include & link for MACOS")
+	target_include_directories(core
+		PRIVATE /usr/local/include)
+	target_link_libraries(core
+		/usr/local/lib/libcrypto.dylib
+		curl
+		/usr/local/lib/libjsoncpp.dylib
+		/usr/local/lib/libuuid.dylib )
 else()
 	target_include_directories(core
 		PRIVATE /usr/include/jsoncpp)

csas/include/alibabacloud/csas/model/GetPrivateAccessApplicationResult.h

@@ -46,6 +46,7 @@ namespace AlibabaCloud
 					std::vector<PortRange> portRanges;
 					std::string createTime;
 					std::vector<std::string> policyIds;
+					std::vector<std::string> connectorIds;
 					std::string applicationId;
 					std::string protocol;
 					std::string name;

csas/include/alibabacloud/csas/model/ListConnectorsResult.h

@@ -44,8 +44,16 @@ namespace AlibabaCloud
 						std::string applicationName;
 						std::string applicationId;
 					};
+					struct ConnectorClient
+					{
+						std::string publicIp;
+						std::string hostname;
+						std::string devTag;
+						std::string connectionStatus;
+					};
 					std::string status;
 					std::vector<Connector::Application> applications;
+					std::vector<Connector::ConnectorClient> connectorClients;
 					std::string createTime;
 					std::string regionId;
 					UpgradeTime upgradeTime;

csas/include/alibabacloud/csas/model/ListPrivateAccessApplicationsRequest.h

@@ -40,6 +40,8 @@ public:
 	void setAddress(const std::string &address);
 	std::string getTagId() const;
 	void setTagId(const std::string &tagId);
+	std::string getConnectorId() const;
+	void setConnectorId(const std::string &connectorId);
 	int getCurrentPage() const;
 	void setCurrentPage(int currentPage);
 	std::vector<std::string> getApplicationIds() const;
@@ -55,6 +57,7 @@ private:
 	int pageSize_;
 	std::string address_;
 	std::string tagId_;
+	std::string connectorId_;
 	int currentPage_;
 	std::vector<std::string> applicationIds_;
 	std::string name_;

csas/include/alibabacloud/csas/model/ListPrivateAccessApplicationsResult.h

@@ -46,6 +46,7 @@ namespace AlibabaCloud
 					std::vector<Application::PortRange> portRanges;
 					std::string createTime;
 					std::vector<std::string> policyIds;
+					std::vector<std::string> connectorIds;
 					std::string applicationId;
 					std::string protocol;
 					std::string name;

csas/src/model/GetPrivateAccessApplicationResult.cc

@@ -71,6 +71,9 @@ void GetPrivateAccessApplicationResult::parse(const std::string &payload)
 		auto allPolicyIds = applicationNode["PolicyIds"]["policyId"];
 		for (auto value : allPolicyIds)
 			application_.policyIds.push_back(value.asString());
+		auto allConnectorIds = applicationNode["ConnectorIds"]["connectorId"];
+		for (auto value : allConnectorIds)
+			application_.connectorIds.push_back(value.asString());
 
 }
 

csas/src/model/ListConnectorsResult.cc

@@ -65,6 +65,20 @@ void ListConnectorsResult::parse(const std::string &payload)
 				applicationsObject.applicationName = valueConnectorsconnectorApplicationsapplication["ApplicationName"].asString();
 			connectorsObject.applications.push_back(applicationsObject);
 		}
+		auto allConnectorClientsNode = valueConnectorsconnector["ConnectorClients"]["connectorClient"];
+		for (auto valueConnectorsconnectorConnectorClientsconnectorClient : allConnectorClientsNode)
+		{
+			Connector::ConnectorClient connectorClientsObject;
+			if(!valueConnectorsconnectorConnectorClientsconnectorClient["DevTag"].isNull())
+				connectorClientsObject.devTag = valueConnectorsconnectorConnectorClientsconnectorClient["DevTag"].asString();
+			if(!valueConnectorsconnectorConnectorClientsconnectorClient["Hostname"].isNull())
+				connectorClientsObject.hostname = valueConnectorsconnectorConnectorClientsconnectorClient["Hostname"].asString();
+			if(!valueConnectorsconnectorConnectorClientsconnectorClient["ConnectionStatus"].isNull())
+				connectorClientsObject.connectionStatus = valueConnectorsconnectorConnectorClientsconnectorClient["ConnectionStatus"].asString();
+			if(!valueConnectorsconnectorConnectorClientsconnectorClient["PublicIp"].isNull())
+				connectorClientsObject.publicIp = valueConnectorsconnectorConnectorClientsconnectorClient["PublicIp"].asString();
+			connectorsObject.connectorClients.push_back(connectorClientsObject);
+		}
 		auto upgradeTimeNode = value["UpgradeTime"];
 		if(!upgradeTimeNode["Start"].isNull())
 			connectorsObject.upgradeTime.start = upgradeTimeNode["Start"].asString();

csas/src/model/ListPrivateAccessApplicationsRequest.cc

@@ -70,6 +70,15 @@ void ListPrivateAccessApplicationsRequest::setTagId(const std::string &tagId) {
   setParameter(std::string("TagId"), tagId);
 }
 
+std::string ListPrivateAccessApplicationsRequest::getConnectorId() const {
+  return connectorId_;
+}
+
+void ListPrivateAccessApplicationsRequest::setConnectorId(const std::string &connectorId) {
+  connectorId_ = connectorId;
+  setParameter(std::string("ConnectorId"), connectorId);
+}
+
 int ListPrivateAccessApplicationsRequest::getCurrentPage() const {
   return currentPage_;
 }

csas/src/model/ListPrivateAccessApplicationsResult.cc

@@ -74,6 +74,9 @@ void ListPrivateAccessApplicationsResult::parse(const std::string &payload)
 		auto allPolicyIds = value["PolicyIds"]["policyId"];
 		for (auto value : allPolicyIds)
 			applicationsObject.policyIds.push_back(value.asString());
+		auto allConnectorIds = value["ConnectorIds"]["connectorId"];
+		for (auto value : allConnectorIds)
+			applicationsObject.connectorIds.push_back(value.asString());
 		applications_.push_back(applicationsObject);
 	}
 	if(!value["TotalNum"].isNull())

dds/include/alibabacloud/dds/model/CreateDBInstanceRequest.h

@@ -74,6 +74,8 @@ public:
 	void setSecurityIPList(const std::string &securityIPList);
 	std::string getVSwitchId() const;
 	void setVSwitchId(const std::string &vSwitchId);
+	long getProvisionedIops() const;
+	void setProvisionedIops(long provisionedIops);
 	std::string getAutoRenew() const;
 	void setAutoRenew(const std::string &autoRenew);
 	std::string getZoneId() const;
@@ -136,6 +138,7 @@ private:
 	std::string dBInstanceClass_;
 	std::string securityIPList_;
 	std::string vSwitchId_;
+	long provisionedIops_;
 	std::string autoRenew_;
 	std::string zoneId_;
 	std::string clientToken_;

dds/include/alibabacloud/dds/model/CreateShardingDBInstanceRequest.h

@@ -82,6 +82,8 @@ public:
 	void setVSwitchId(const std::string &vSwitchId);
 	std::vector<Mongos> getMongos() const;
 	void setMongos(const std::vector<Mongos> &mongos);
+	long getProvisionedIops() const;
+	void setProvisionedIops(long provisionedIops);
 	std::string getAutoRenew() const;
 	void setAutoRenew(const std::string &autoRenew);
 	std::string getZoneId() const;
@@ -136,6 +138,7 @@ private:
 	std::string securityIPList_;
 	std::string vSwitchId_;
 	std::vector<Mongos> mongos_;
+	long provisionedIops_;
 	std::string autoRenew_;
 	std::string zoneId_;
 	std::string clientToken_;

dds/include/alibabacloud/dds/model/DescribeAvailableResourceRequest.h

@@ -32,6 +32,8 @@ public:
 	~DescribeAvailableResourceRequest();
 	long getResourceOwnerId() const;
 	void setResourceOwnerId(long resourceOwnerId);
+	std::string getStorageType() const;
+	void setStorageType(const std::string &storageType);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
 	std::string getResourceGroupId() const;
@@ -61,6 +63,7 @@ public:
 
 private:
 	long resourceOwnerId_;
+	std::string storageType_;
 	std::string accessKeyId_;
 	std::string resourceGroupId_;
 	std::string securityToken_;

dds/include/alibabacloud/dds/model/DescribeDBInstanceAttributeResult.h

@@ -126,6 +126,7 @@ namespace AlibabaCloud
 					std::string dBInstanceClass;
 					std::string vSwitchId;
 					std::string lockMode;
+					long provisionedIops;
 					std::string currentKernelVersion;
 					std::string creationTime;
 					std::vector<DBInstance::NetworkAddress> networkAddresses;
@@ -139,6 +140,7 @@ namespace AlibabaCloud
 					std::string networkType;
 					std::string paymentType;
 					std::string maintainStartTime;
+					bool burstingEnabled;
 					std::string zoneId;
 					std::string readonlyReplicas;
 					std::string replicationFactor;

dds/include/alibabacloud/dds/model/DescribeRegionsResult.h

@@ -43,6 +43,7 @@ namespace AlibabaCloud
 					std::string regionName;
 					std::string zoneIds;
 					std::string regionId;
+					std::string endPoint;
 					std::vector<DdsRegion::Zone> zones;
 				};
 

dds/include/alibabacloud/dds/model/TransformInstanceChargeTypeRequest.h

@@ -58,6 +58,8 @@ public:
 	void setAutoRenew(const std::string &autoRenew);
 	std::string getChargeType() const;
 	void setChargeType(const std::string &chargeType);
+	std::string getPricingCycle() const;
+	void setPricingCycle(const std::string &pricingCycle);
 
 private:
 	long resourceOwnerId_;
@@ -74,6 +76,7 @@ private:
 	std::string instanceId_;
 	std::string autoRenew_;
 	std::string chargeType_;
+	std::string pricingCycle_;
 };
 } // namespace Model
 } // namespace Dds

dds/src/model/CreateDBInstanceRequest.cc

@@ -210,6 +210,15 @@ void CreateDBInstanceRequest::setVSwitchId(const std::string &vSwitchId) {
   setParameter(std::string("VSwitchId"), vSwitchId);
 }
 
+long CreateDBInstanceRequest::getProvisionedIops() const {
+  return provisionedIops_;
+}
+
+void CreateDBInstanceRequest::setProvisionedIops(long provisionedIops) {
+  provisionedIops_ = provisionedIops;
+  setParameter(std::string("ProvisionedIops"), std::to_string(provisionedIops));
+}
+
 std::string CreateDBInstanceRequest::getAutoRenew() const {
   return autoRenew_;
 }

dds/src/model/CreateShardingDBInstanceRequest.cc

@@ -207,6 +207,15 @@ void CreateShardingDBInstanceRequest::setMongos(const std::vector<CreateSharding
   }
 }
 
+long CreateShardingDBInstanceRequest::getProvisionedIops() const {
+  return provisionedIops_;
+}
+
+void CreateShardingDBInstanceRequest::setProvisionedIops(long provisionedIops) {
+  provisionedIops_ = provisionedIops;
+  setParameter(std::string("ProvisionedIops"), std::to_string(provisionedIops));
+}
+
 std::string CreateShardingDBInstanceRequest::getAutoRenew() const {
   return autoRenew_;
 }

dds/src/model/DescribeAvailableResourceRequest.cc

@@ -34,6 +34,15 @@ void DescribeAvailableResourceRequest::setResourceOwnerId(long resourceOwnerId)
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
+std::string DescribeAvailableResourceRequest::getStorageType() const {
+  return storageType_;
+}
+
+void DescribeAvailableResourceRequest::setStorageType(const std::string &storageType) {
+  storageType_ = storageType;
+  setParameter(std::string("StorageType"), storageType);
+}
+
 std::string DescribeAvailableResourceRequest::getAccessKeyId() const {
   return accessKeyId_;
 }

dds/src/model/DescribeDBInstanceAttributeResult.cc

@@ -133,6 +133,10 @@ void DescribeDBInstanceAttributeResult::parse(const std::string &payload)
 			dBInstancesObject.encryptionKey = valueDBInstancesDBInstance["EncryptionKey"].asString();
 		if(!valueDBInstancesDBInstance["SyncPercent"].isNull())
 			dBInstancesObject.syncPercent = valueDBInstancesDBInstance["SyncPercent"].asString();
+		if(!valueDBInstancesDBInstance["BurstingEnabled"].isNull())
+			dBInstancesObject.burstingEnabled = valueDBInstancesDBInstance["BurstingEnabled"].asString() == "true";
+		if(!valueDBInstancesDBInstance["ProvisionedIops"].isNull())
+			dBInstancesObject.provisionedIops = std::stol(valueDBInstancesDBInstance["ProvisionedIops"].asString());
 		auto allReplicaSetsNode = valueDBInstancesDBInstance["ReplicaSets"]["ReplicaSet"];
 		for (auto valueDBInstancesDBInstanceReplicaSetsReplicaSet : allReplicaSetsNode)
 		{

dds/src/model/DescribeRegionsResult.cc

@@ -49,6 +49,8 @@ void DescribeRegionsResult::parse(const std::string &payload)
 			regionsObject.regionId = valueRegionsDdsRegion["RegionId"].asString();
 		if(!valueRegionsDdsRegion["RegionName"].isNull())
 			regionsObject.regionName = valueRegionsDdsRegion["RegionName"].asString();
+		if(!valueRegionsDdsRegion["EndPoint"].isNull())
+			regionsObject.endPoint = valueRegionsDdsRegion["EndPoint"].asString();
 		auto allZonesNode = valueRegionsDdsRegion["Zones"]["Zone"];
 		for (auto valueRegionsDdsRegionZonesZone : allZonesNode)
 		{

dds/src/model/TransformInstanceChargeTypeRequest.cc

@@ -151,3 +151,12 @@ void TransformInstanceChargeTypeRequest::setChargeType(const std::string &charge
   setParameter(std::string("ChargeType"), chargeType);
 }
 
+std::string TransformInstanceChargeTypeRequest::getPricingCycle() const {
+  return pricingCycle_;
+}
+
+void TransformInstanceChargeTypeRequest::setPricingCycle(const std::string &pricingCycle) {
+  pricingCycle_ = pricingCycle;
+  setParameter(std::string("PricingCycle"), pricingCycle);
+}
+

easyinstall.sh

@@ -7,11 +7,11 @@ if command -v python > /dev/null ; then
   MAKE="make -j $(python -c 'import multiprocessing as mp; print(int(mp.cpu_count()))')"
 fi
 
-echo $MAKE
+echo "$MAKE"
 
 rm -rf sdk_build
 mkdir sdk_build
-cd sdk_build
+cd sdk_build || exit
 cmake -DBUILD_PRODUCT="$product" -DBUILD_FUNCTION_TESTS=OFF -DBUILD_UNIT_TESTS=OFF -DENABLE_COVERAGE=OFF -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr ..
 $MAKE
 

eflo/CMakeLists.txt

@@ -21,30 +21,130 @@ set(eflo_public_header
 	include/alibabacloud/eflo/EfloExport.h )
 
 set(eflo_public_header_model 
+	include/alibabacloud/eflo/model/AssignPrivateIpAddressRequest.h
+	include/alibabacloud/eflo/model/AssignPrivateIpAddressResult.h
+	include/alibabacloud/eflo/model/AssociateVpdCidrBlockRequest.h
+	include/alibabacloud/eflo/model/AssociateVpdCidrBlockResult.h
+	include/alibabacloud/eflo/model/CreateElasticNetworkInterfaceRequest.h
+	include/alibabacloud/eflo/model/CreateElasticNetworkInterfaceResult.h
+	include/alibabacloud/eflo/model/CreateErRequest.h
+	include/alibabacloud/eflo/model/CreateErResult.h
+	include/alibabacloud/eflo/model/CreateErAttachmentRequest.h
+	include/alibabacloud/eflo/model/CreateErAttachmentResult.h
+	include/alibabacloud/eflo/model/CreateErRouteMapRequest.h
+	include/alibabacloud/eflo/model/CreateErRouteMapResult.h
 	include/alibabacloud/eflo/model/CreateSubnetRequest.h
 	include/alibabacloud/eflo/model/CreateSubnetResult.h
 	include/alibabacloud/eflo/model/CreateVccRequest.h
 	include/alibabacloud/eflo/model/CreateVccResult.h
+	include/alibabacloud/eflo/model/CreateVccGrantRuleRequest.h
+	include/alibabacloud/eflo/model/CreateVccGrantRuleResult.h
+	include/alibabacloud/eflo/model/CreateVccRouteEntryRequest.h
+	include/alibabacloud/eflo/model/CreateVccRouteEntryResult.h
 	include/alibabacloud/eflo/model/CreateVpdRequest.h
 	include/alibabacloud/eflo/model/CreateVpdResult.h
+	include/alibabacloud/eflo/model/CreateVpdGrantRuleRequest.h
+	include/alibabacloud/eflo/model/CreateVpdGrantRuleResult.h
+	include/alibabacloud/eflo/model/DeleteElasticNetworkInterfaceRequest.h
+	include/alibabacloud/eflo/model/DeleteElasticNetworkInterfaceResult.h
+	include/alibabacloud/eflo/model/DeleteErRequest.h
+	include/alibabacloud/eflo/model/DeleteErResult.h
+	include/alibabacloud/eflo/model/DeleteErAttachmentRequest.h
+	include/alibabacloud/eflo/model/DeleteErAttachmentResult.h
+	include/alibabacloud/eflo/model/DeleteErRouteMapRequest.h
+	include/alibabacloud/eflo/model/DeleteErRouteMapResult.h
 	include/alibabacloud/eflo/model/DeleteSubnetRequest.h
 	include/alibabacloud/eflo/model/DeleteSubnetResult.h
+	include/alibabacloud/eflo/model/DeleteVccGrantRuleRequest.h
+	include/alibabacloud/eflo/model/DeleteVccGrantRuleResult.h
+	include/alibabacloud/eflo/model/DeleteVccRouteEntryRequest.h
+	include/alibabacloud/eflo/model/DeleteVccRouteEntryResult.h
 	include/alibabacloud/eflo/model/DeleteVpdRequest.h
 	include/alibabacloud/eflo/model/DeleteVpdResult.h
+	include/alibabacloud/eflo/model/DeleteVpdGrantRuleRequest.h
+	include/alibabacloud/eflo/model/DeleteVpdGrantRuleResult.h
+	include/alibabacloud/eflo/model/DescribeSlrRequest.h
+	include/alibabacloud/eflo/model/DescribeSlrResult.h
+	include/alibabacloud/eflo/model/GetElasticNetworkInterfaceRequest.h
+	include/alibabacloud/eflo/model/GetElasticNetworkInterfaceResult.h
+	include/alibabacloud/eflo/model/GetErRequest.h
+	include/alibabacloud/eflo/model/GetErResult.h
+	include/alibabacloud/eflo/model/GetErAttachmentRequest.h
+	include/alibabacloud/eflo/model/GetErAttachmentResult.h
+	include/alibabacloud/eflo/model/GetErRouteEntryRequest.h
+	include/alibabacloud/eflo/model/GetErRouteEntryResult.h
+	include/alibabacloud/eflo/model/GetErRouteMapRequest.h
+	include/alibabacloud/eflo/model/GetErRouteMapResult.h
+	include/alibabacloud/eflo/model/GetFabricTopologyRequest.h
+	include/alibabacloud/eflo/model/GetFabricTopologyResult.h
+	include/alibabacloud/eflo/model/GetLniPrivateIpAddressRequest.h
+	include/alibabacloud/eflo/model/GetLniPrivateIpAddressResult.h
+	include/alibabacloud/eflo/model/GetNetworkInterfaceRequest.h
+	include/alibabacloud/eflo/model/GetNetworkInterfaceResult.h
+	include/alibabacloud/eflo/model/GetNodeInfoForPodRequest.h
+	include/alibabacloud/eflo/model/GetNodeInfoForPodResult.h
 	include/alibabacloud/eflo/model/GetSubnetRequest.h
 	include/alibabacloud/eflo/model/GetSubnetResult.h
 	include/alibabacloud/eflo/model/GetVccRequest.h
 	include/alibabacloud/eflo/model/GetVccResult.h
+	include/alibabacloud/eflo/model/GetVccGrantRuleRequest.h
+	include/alibabacloud/eflo/model/GetVccGrantRuleResult.h
+	include/alibabacloud/eflo/model/GetVccRouteEntryRequest.h
+	include/alibabacloud/eflo/model/GetVccRouteEntryResult.h
 	include/alibabacloud/eflo/model/GetVpdRequest.h
 	include/alibabacloud/eflo/model/GetVpdResult.h
+	include/alibabacloud/eflo/model/GetVpdGrantRuleRequest.h
+	include/alibabacloud/eflo/model/GetVpdGrantRuleResult.h
+	include/alibabacloud/eflo/model/GetVpdRouteEntryRequest.h
+	include/alibabacloud/eflo/model/GetVpdRouteEntryResult.h
 	include/alibabacloud/eflo/model/InitializeVccRequest.h
 	include/alibabacloud/eflo/model/InitializeVccResult.h
+	include/alibabacloud/eflo/model/ListElasticNetworkInterfacesRequest.h
+	include/alibabacloud/eflo/model/ListElasticNetworkInterfacesResult.h
+	include/alibabacloud/eflo/model/ListErAttachmentsRequest.h
+	include/alibabacloud/eflo/model/ListErAttachmentsResult.h
+	include/alibabacloud/eflo/model/ListErRouteEntriesRequest.h
+	include/alibabacloud/eflo/model/ListErRouteEntriesResult.h
+	include/alibabacloud/eflo/model/ListErRouteMapsRequest.h
+	include/alibabacloud/eflo/model/ListErRouteMapsResult.h
+	include/alibabacloud/eflo/model/ListErsRequest.h
+	include/alibabacloud/eflo/model/ListErsResult.h
+	include/alibabacloud/eflo/model/ListInstancesByNcdRequest.h
+	include/alibabacloud/eflo/model/ListInstancesByNcdResult.h
+	include/alibabacloud/eflo/model/ListLniPrivateIpAddressRequest.h
+	include/alibabacloud/eflo/model/ListLniPrivateIpAddressResult.h
+	include/alibabacloud/eflo/model/ListNetworkInterfacesRequest.h
+	include/alibabacloud/eflo/model/ListNetworkInterfacesResult.h
+	include/alibabacloud/eflo/model/ListNodeInfosForPodRequest.h
+	include/alibabacloud/eflo/model/ListNodeInfosForPodResult.h
 	include/alibabacloud/eflo/model/ListSubnetsRequest.h
 	include/alibabacloud/eflo/model/ListSubnetsResult.h
+	include/alibabacloud/eflo/model/ListVccGrantRulesRequest.h
+	include/alibabacloud/eflo/model/ListVccGrantRulesResult.h
+	include/alibabacloud/eflo/model/ListVccRouteEntriesRequest.h
+	include/alibabacloud/eflo/model/ListVccRouteEntriesResult.h
 	include/alibabacloud/eflo/model/ListVccsRequest.h
 	include/alibabacloud/eflo/model/ListVccsResult.h
+	include/alibabacloud/eflo/model/ListVpdGrantRulesRequest.h
+	include/alibabacloud/eflo/model/ListVpdGrantRulesResult.h
+	include/alibabacloud/eflo/model/ListVpdRouteEntriesRequest.h
+	include/alibabacloud/eflo/model/ListVpdRouteEntriesResult.h
 	include/alibabacloud/eflo/model/ListVpdsRequest.h
 	include/alibabacloud/eflo/model/ListVpdsResult.h
+	include/alibabacloud/eflo/model/QueryInstanceNcdRequest.h
+	include/alibabacloud/eflo/model/QueryInstanceNcdResult.h
+	include/alibabacloud/eflo/model/UnAssignPrivateIpAddressRequest.h
+	include/alibabacloud/eflo/model/UnAssignPrivateIpAddressResult.h
+	include/alibabacloud/eflo/model/UnAssociateVpdCidrBlockRequest.h
+	include/alibabacloud/eflo/model/UnAssociateVpdCidrBlockResult.h
+	include/alibabacloud/eflo/model/UpdateElasticNetworkInterfaceRequest.h
+	include/alibabacloud/eflo/model/UpdateElasticNetworkInterfaceResult.h
+	include/alibabacloud/eflo/model/UpdateErRequest.h
+	include/alibabacloud/eflo/model/UpdateErResult.h
+	include/alibabacloud/eflo/model/UpdateErAttachmentRequest.h
+	include/alibabacloud/eflo/model/UpdateErAttachmentResult.h
+	include/alibabacloud/eflo/model/UpdateErRouteMapRequest.h
+	include/alibabacloud/eflo/model/UpdateErRouteMapResult.h
 	include/alibabacloud/eflo/model/UpdateSubnetRequest.h
 	include/alibabacloud/eflo/model/UpdateSubnetResult.h
 	include/alibabacloud/eflo/model/UpdateVccRequest.h
@@ -54,30 +154,130 @@ set(eflo_public_header_model
 
 set(eflo_src 
 	src/EfloClient.cc
+	src/model/AssignPrivateIpAddressRequest.cc
+	src/model/AssignPrivateIpAddressResult.cc
+	src/model/AssociateVpdCidrBlockRequest.cc
+	src/model/AssociateVpdCidrBlockResult.cc
+	src/model/CreateElasticNetworkInterfaceRequest.cc
+	src/model/CreateElasticNetworkInterfaceResult.cc
+	src/model/CreateErRequest.cc
+	src/model/CreateErResult.cc
+	src/model/CreateErAttachmentRequest.cc
+	src/model/CreateErAttachmentResult.cc
+	src/model/CreateErRouteMapRequest.cc
+	src/model/CreateErRouteMapResult.cc
 	src/model/CreateSubnetRequest.cc
 	src/model/CreateSubnetResult.cc
 	src/model/CreateVccRequest.cc
 	src/model/CreateVccResult.cc
+	src/model/CreateVccGrantRuleRequest.cc
+	src/model/CreateVccGrantRuleResult.cc
+	src/model/CreateVccRouteEntryRequest.cc
+	src/model/CreateVccRouteEntryResult.cc
 	src/model/CreateVpdRequest.cc
 	src/model/CreateVpdResult.cc
+	src/model/CreateVpdGrantRuleRequest.cc
+	src/model/CreateVpdGrantRuleResult.cc
+	src/model/DeleteElasticNetworkInterfaceRequest.cc
+	src/model/DeleteElasticNetworkInterfaceResult.cc
+	src/model/DeleteErRequest.cc
+	src/model/DeleteErResult.cc
+	src/model/DeleteErAttachmentRequest.cc
+	src/model/DeleteErAttachmentResult.cc
+	src/model/DeleteErRouteMapRequest.cc
+	src/model/DeleteErRouteMapResult.cc
 	src/model/DeleteSubnetRequest.cc
 	src/model/DeleteSubnetResult.cc
+	src/model/DeleteVccGrantRuleRequest.cc
+	src/model/DeleteVccGrantRuleResult.cc
+	src/model/DeleteVccRouteEntryRequest.cc
+	src/model/DeleteVccRouteEntryResult.cc
 	src/model/DeleteVpdRequest.cc
 	src/model/DeleteVpdResult.cc
+	src/model/DeleteVpdGrantRuleRequest.cc
+	src/model/DeleteVpdGrantRuleResult.cc
+	src/model/DescribeSlrRequest.cc
+	src/model/DescribeSlrResult.cc
+	src/model/GetElasticNetworkInterfaceRequest.cc
+	src/model/GetElasticNetworkInterfaceResult.cc
+	src/model/GetErRequest.cc
+	src/model/GetErResult.cc
+	src/model/GetErAttachmentRequest.cc
+	src/model/GetErAttachmentResult.cc
+	src/model/GetErRouteEntryRequest.cc
+	src/model/GetErRouteEntryResult.cc
+	src/model/GetErRouteMapRequest.cc
+	src/model/GetErRouteMapResult.cc
+	src/model/GetFabricTopologyRequest.cc
+	src/model/GetFabricTopologyResult.cc
+	src/model/GetLniPrivateIpAddressRequest.cc
+	src/model/GetLniPrivateIpAddressResult.cc
+	src/model/GetNetworkInterfaceRequest.cc
+	src/model/GetNetworkInterfaceResult.cc
+	src/model/GetNodeInfoForPodRequest.cc
+	src/model/GetNodeInfoForPodResult.cc
 	src/model/GetSubnetRequest.cc
 	src/model/GetSubnetResult.cc
 	src/model/GetVccRequest.cc
 	src/model/GetVccResult.cc
+	src/model/GetVccGrantRuleRequest.cc
+	src/model/GetVccGrantRuleResult.cc
+	src/model/GetVccRouteEntryRequest.cc
+	src/model/GetVccRouteEntryResult.cc
 	src/model/GetVpdRequest.cc
 	src/model/GetVpdResult.cc
+	src/model/GetVpdGrantRuleRequest.cc
+	src/model/GetVpdGrantRuleResult.cc
+	src/model/GetVpdRouteEntryRequest.cc
+	src/model/GetVpdRouteEntryResult.cc
 	src/model/InitializeVccRequest.cc
 	src/model/InitializeVccResult.cc
+	src/model/ListElasticNetworkInterfacesRequest.cc
+	src/model/ListElasticNetworkInterfacesResult.cc
+	src/model/ListErAttachmentsRequest.cc
+	src/model/ListErAttachmentsResult.cc
+	src/model/ListErRouteEntriesRequest.cc
+	src/model/ListErRouteEntriesResult.cc
+	src/model/ListErRouteMapsRequest.cc
+	src/model/ListErRouteMapsResult.cc
+	src/model/ListErsRequest.cc
+	src/model/ListErsResult.cc
+	src/model/ListInstancesByNcdRequest.cc
+	src/model/ListInstancesByNcdResult.cc
+	src/model/ListLniPrivateIpAddressRequest.cc
+	src/model/ListLniPrivateIpAddressResult.cc
+	src/model/ListNetworkInterfacesRequest.cc
+	src/model/ListNetworkInterfacesResult.cc
+	src/model/ListNodeInfosForPodRequest.cc
+	src/model/ListNodeInfosForPodResult.cc
 	src/model/ListSubnetsRequest.cc
 	src/model/ListSubnetsResult.cc
+	src/model/ListVccGrantRulesRequest.cc
+	src/model/ListVccGrantRulesResult.cc
+	src/model/ListVccRouteEntriesRequest.cc
+	src/model/ListVccRouteEntriesResult.cc
 	src/model/ListVccsRequest.cc
 	src/model/ListVccsResult.cc
+	src/model/ListVpdGrantRulesRequest.cc
+	src/model/ListVpdGrantRulesResult.cc
+	src/model/ListVpdRouteEntriesRequest.cc
+	src/model/ListVpdRouteEntriesResult.cc
 	src/model/ListVpdsRequest.cc
 	src/model/ListVpdsResult.cc
+	src/model/QueryInstanceNcdRequest.cc
+	src/model/QueryInstanceNcdResult.cc
+	src/model/UnAssignPrivateIpAddressRequest.cc
+	src/model/UnAssignPrivateIpAddressResult.cc
+	src/model/UnAssociateVpdCidrBlockRequest.cc
+	src/model/UnAssociateVpdCidrBlockResult.cc
+	src/model/UpdateElasticNetworkInterfaceRequest.cc
+	src/model/UpdateElasticNetworkInterfaceResult.cc
+	src/model/UpdateErRequest.cc
+	src/model/UpdateErResult.cc
+	src/model/UpdateErAttachmentRequest.cc
+	src/model/UpdateErAttachmentResult.cc
+	src/model/UpdateErRouteMapRequest.cc
+	src/model/UpdateErRouteMapResult.cc
 	src/model/UpdateSubnetRequest.cc
 	src/model/UpdateSubnetResult.cc
 	src/model/UpdateVccRequest.cc

eflo/include/alibabacloud/eflo/EfloClient.h

@@ -22,30 +22,130 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "EfloExport.h"
+#include "model/AssignPrivateIpAddressRequest.h"
+#include "model/AssignPrivateIpAddressResult.h"
+#include "model/AssociateVpdCidrBlockRequest.h"
+#include "model/AssociateVpdCidrBlockResult.h"
+#include "model/CreateElasticNetworkInterfaceRequest.h"
+#include "model/CreateElasticNetworkInterfaceResult.h"
+#include "model/CreateErRequest.h"
+#include "model/CreateErResult.h"
+#include "model/CreateErAttachmentRequest.h"
+#include "model/CreateErAttachmentResult.h"
+#include "model/CreateErRouteMapRequest.h"
+#include "model/CreateErRouteMapResult.h"
 #include "model/CreateSubnetRequest.h"
 #include "model/CreateSubnetResult.h"
 #include "model/CreateVccRequest.h"
 #include "model/CreateVccResult.h"
+#include "model/CreateVccGrantRuleRequest.h"
+#include "model/CreateVccGrantRuleResult.h"
+#include "model/CreateVccRouteEntryRequest.h"
+#include "model/CreateVccRouteEntryResult.h"
 #include "model/CreateVpdRequest.h"
 #include "model/CreateVpdResult.h"
+#include "model/CreateVpdGrantRuleRequest.h"
+#include "model/CreateVpdGrantRuleResult.h"
+#include "model/DeleteElasticNetworkInterfaceRequest.h"
+#include "model/DeleteElasticNetworkInterfaceResult.h"
+#include "model/DeleteErRequest.h"
+#include "model/DeleteErResult.h"
+#include "model/DeleteErAttachmentRequest.h"
+#include "model/DeleteErAttachmentResult.h"
+#include "model/DeleteErRouteMapRequest.h"
+#include "model/DeleteErRouteMapResult.h"
 #include "model/DeleteSubnetRequest.h"
 #include "model/DeleteSubnetResult.h"
+#include "model/DeleteVccGrantRuleRequest.h"
+#include "model/DeleteVccGrantRuleResult.h"
+#include "model/DeleteVccRouteEntryRequest.h"
+#include "model/DeleteVccRouteEntryResult.h"
 #include "model/DeleteVpdRequest.h"
 #include "model/DeleteVpdResult.h"
+#include "model/DeleteVpdGrantRuleRequest.h"
+#include "model/DeleteVpdGrantRuleResult.h"
+#include "model/DescribeSlrRequest.h"
+#include "model/DescribeSlrResult.h"
+#include "model/GetElasticNetworkInterfaceRequest.h"
+#include "model/GetElasticNetworkInterfaceResult.h"
+#include "model/GetErRequest.h"
+#include "model/GetErResult.h"
+#include "model/GetErAttachmentRequest.h"
+#include "model/GetErAttachmentResult.h"
+#include "model/GetErRouteEntryRequest.h"
+#include "model/GetErRouteEntryResult.h"
+#include "model/GetErRouteMapRequest.h"
+#include "model/GetErRouteMapResult.h"
+#include "model/GetFabricTopologyRequest.h"
+#include "model/GetFabricTopologyResult.h"
+#include "model/GetLniPrivateIpAddressRequest.h"
+#include "model/GetLniPrivateIpAddressResult.h"
+#include "model/GetNetworkInterfaceRequest.h"
+#include "model/GetNetworkInterfaceResult.h"
+#include "model/GetNodeInfoForPodRequest.h"
+#include "model/GetNodeInfoForPodResult.h"
 #include "model/GetSubnetRequest.h"
 #include "model/GetSubnetResult.h"
 #include "model/GetVccRequest.h"
 #include "model/GetVccResult.h"
+#include "model/GetVccGrantRuleRequest.h"
+#include "model/GetVccGrantRuleResult.h"
+#include "model/GetVccRouteEntryRequest.h"
+#include "model/GetVccRouteEntryResult.h"
 #include "model/GetVpdRequest.h"
 #include "model/GetVpdResult.h"
+#include "model/GetVpdGrantRuleRequest.h"
+#include "model/GetVpdGrantRuleResult.h"
+#include "model/GetVpdRouteEntryRequest.h"
+#include "model/GetVpdRouteEntryResult.h"
 #include "model/InitializeVccRequest.h"
 #include "model/InitializeVccResult.h"
+#include "model/ListElasticNetworkInterfacesRequest.h"
+#include "model/ListElasticNetworkInterfacesResult.h"
+#include "model/ListErAttachmentsRequest.h"
+#include "model/ListErAttachmentsResult.h"
+#include "model/ListErRouteEntriesRequest.h"
+#include "model/ListErRouteEntriesResult.h"
+#include "model/ListErRouteMapsRequest.h"
+#include "model/ListErRouteMapsResult.h"
+#include "model/ListErsRequest.h"
+#include "model/ListErsResult.h"
+#include "model/ListInstancesByNcdRequest.h"
+#include "model/ListInstancesByNcdResult.h"
+#include "model/ListLniPrivateIpAddressRequest.h"
+#include "model/ListLniPrivateIpAddressResult.h"
+#include "model/ListNetworkInterfacesRequest.h"
+#include "model/ListNetworkInterfacesResult.h"
+#include "model/ListNodeInfosForPodRequest.h"
+#include "model/ListNodeInfosForPodResult.h"
 #include "model/ListSubnetsRequest.h"
 #include "model/ListSubnetsResult.h"
+#include "model/ListVccGrantRulesRequest.h"
+#include "model/ListVccGrantRulesResult.h"
+#include "model/ListVccRouteEntriesRequest.h"
+#include "model/ListVccRouteEntriesResult.h"
 #include "model/ListVccsRequest.h"
 #include "model/ListVccsResult.h"
+#include "model/ListVpdGrantRulesRequest.h"
+#include "model/ListVpdGrantRulesResult.h"
+#include "model/ListVpdRouteEntriesRequest.h"
+#include "model/ListVpdRouteEntriesResult.h"
 #include "model/ListVpdsRequest.h"
 #include "model/ListVpdsResult.h"
+#include "model/QueryInstanceNcdRequest.h"
+#include "model/QueryInstanceNcdResult.h"
+#include "model/UnAssignPrivateIpAddressRequest.h"
+#include "model/UnAssignPrivateIpAddressResult.h"
+#include "model/UnAssociateVpdCidrBlockRequest.h"
+#include "model/UnAssociateVpdCidrBlockResult.h"
+#include "model/UpdateElasticNetworkInterfaceRequest.h"
+#include "model/UpdateElasticNetworkInterfaceResult.h"
+#include "model/UpdateErRequest.h"
+#include "model/UpdateErResult.h"
+#include "model/UpdateErAttachmentRequest.h"
+#include "model/UpdateErAttachmentResult.h"
+#include "model/UpdateErRouteMapRequest.h"
+#include "model/UpdateErRouteMapResult.h"
 #include "model/UpdateSubnetRequest.h"
 #include "model/UpdateSubnetResult.h"
 #include "model/UpdateVccRequest.h"
@@ -61,42 +161,192 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_EFLO_EXPORT EfloClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::AssignPrivateIpAddressResult> AssignPrivateIpAddressOutcome;
+			typedef std::future<AssignPrivateIpAddressOutcome> AssignPrivateIpAddressOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::AssignPrivateIpAddressRequest&, const AssignPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssignPrivateIpAddressAsyncHandler;
+			typedef Outcome<Error, Model::AssociateVpdCidrBlockResult> AssociateVpdCidrBlockOutcome;
+			typedef std::future<AssociateVpdCidrBlockOutcome> AssociateVpdCidrBlockOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::AssociateVpdCidrBlockRequest&, const AssociateVpdCidrBlockOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssociateVpdCidrBlockAsyncHandler;
+			typedef Outcome<Error, Model::CreateElasticNetworkInterfaceResult> CreateElasticNetworkInterfaceOutcome;
+			typedef std::future<CreateElasticNetworkInterfaceOutcome> CreateElasticNetworkInterfaceOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::CreateElasticNetworkInterfaceRequest&, const CreateElasticNetworkInterfaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateElasticNetworkInterfaceAsyncHandler;
+			typedef Outcome<Error, Model::CreateErResult> CreateErOutcome;
+			typedef std::future<CreateErOutcome> CreateErOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::CreateErRequest&, const CreateErOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateErAsyncHandler;
+			typedef Outcome<Error, Model::CreateErAttachmentResult> CreateErAttachmentOutcome;
+			typedef std::future<CreateErAttachmentOutcome> CreateErAttachmentOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::CreateErAttachmentRequest&, const CreateErAttachmentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateErAttachmentAsyncHandler;
+			typedef Outcome<Error, Model::CreateErRouteMapResult> CreateErRouteMapOutcome;
+			typedef std::future<CreateErRouteMapOutcome> CreateErRouteMapOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::CreateErRouteMapRequest&, const CreateErRouteMapOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateErRouteMapAsyncHandler;
 			typedef Outcome<Error, Model::CreateSubnetResult> CreateSubnetOutcome;
 			typedef std::future<CreateSubnetOutcome> CreateSubnetOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::CreateSubnetRequest&, const CreateSubnetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSubnetAsyncHandler;
 			typedef Outcome<Error, Model::CreateVccResult> CreateVccOutcome;
 			typedef std::future<CreateVccOutcome> CreateVccOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::CreateVccRequest&, const CreateVccOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVccAsyncHandler;
+			typedef Outcome<Error, Model::CreateVccGrantRuleResult> CreateVccGrantRuleOutcome;
+			typedef std::future<CreateVccGrantRuleOutcome> CreateVccGrantRuleOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::CreateVccGrantRuleRequest&, const CreateVccGrantRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVccGrantRuleAsyncHandler;
+			typedef Outcome<Error, Model::CreateVccRouteEntryResult> CreateVccRouteEntryOutcome;
+			typedef std::future<CreateVccRouteEntryOutcome> CreateVccRouteEntryOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::CreateVccRouteEntryRequest&, const CreateVccRouteEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVccRouteEntryAsyncHandler;
 			typedef Outcome<Error, Model::CreateVpdResult> CreateVpdOutcome;
 			typedef std::future<CreateVpdOutcome> CreateVpdOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::CreateVpdRequest&, const CreateVpdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVpdAsyncHandler;
+			typedef Outcome<Error, Model::CreateVpdGrantRuleResult> CreateVpdGrantRuleOutcome;
+			typedef std::future<CreateVpdGrantRuleOutcome> CreateVpdGrantRuleOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::CreateVpdGrantRuleRequest&, const CreateVpdGrantRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVpdGrantRuleAsyncHandler;
+			typedef Outcome<Error, Model::DeleteElasticNetworkInterfaceResult> DeleteElasticNetworkInterfaceOutcome;
+			typedef std::future<DeleteElasticNetworkInterfaceOutcome> DeleteElasticNetworkInterfaceOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DeleteElasticNetworkInterfaceRequest&, const DeleteElasticNetworkInterfaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteElasticNetworkInterfaceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteErResult> DeleteErOutcome;
+			typedef std::future<DeleteErOutcome> DeleteErOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DeleteErRequest&, const DeleteErOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteErAsyncHandler;
+			typedef Outcome<Error, Model::DeleteErAttachmentResult> DeleteErAttachmentOutcome;
+			typedef std::future<DeleteErAttachmentOutcome> DeleteErAttachmentOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DeleteErAttachmentRequest&, const DeleteErAttachmentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteErAttachmentAsyncHandler;
+			typedef Outcome<Error, Model::DeleteErRouteMapResult> DeleteErRouteMapOutcome;
+			typedef std::future<DeleteErRouteMapOutcome> DeleteErRouteMapOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DeleteErRouteMapRequest&, const DeleteErRouteMapOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteErRouteMapAsyncHandler;
 			typedef Outcome<Error, Model::DeleteSubnetResult> DeleteSubnetOutcome;
 			typedef std::future<DeleteSubnetOutcome> DeleteSubnetOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::DeleteSubnetRequest&, const DeleteSubnetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSubnetAsyncHandler;
+			typedef Outcome<Error, Model::DeleteVccGrantRuleResult> DeleteVccGrantRuleOutcome;
+			typedef std::future<DeleteVccGrantRuleOutcome> DeleteVccGrantRuleOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DeleteVccGrantRuleRequest&, const DeleteVccGrantRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVccGrantRuleAsyncHandler;
+			typedef Outcome<Error, Model::DeleteVccRouteEntryResult> DeleteVccRouteEntryOutcome;
+			typedef std::future<DeleteVccRouteEntryOutcome> DeleteVccRouteEntryOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DeleteVccRouteEntryRequest&, const DeleteVccRouteEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVccRouteEntryAsyncHandler;
 			typedef Outcome<Error, Model::DeleteVpdResult> DeleteVpdOutcome;
 			typedef std::future<DeleteVpdOutcome> DeleteVpdOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::DeleteVpdRequest&, const DeleteVpdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVpdAsyncHandler;
+			typedef Outcome<Error, Model::DeleteVpdGrantRuleResult> DeleteVpdGrantRuleOutcome;
+			typedef std::future<DeleteVpdGrantRuleOutcome> DeleteVpdGrantRuleOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DeleteVpdGrantRuleRequest&, const DeleteVpdGrantRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVpdGrantRuleAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSlrResult> DescribeSlrOutcome;
+			typedef std::future<DescribeSlrOutcome> DescribeSlrOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DescribeSlrRequest&, const DescribeSlrOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSlrAsyncHandler;
+			typedef Outcome<Error, Model::GetElasticNetworkInterfaceResult> GetElasticNetworkInterfaceOutcome;
+			typedef std::future<GetElasticNetworkInterfaceOutcome> GetElasticNetworkInterfaceOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetElasticNetworkInterfaceRequest&, const GetElasticNetworkInterfaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetElasticNetworkInterfaceAsyncHandler;
+			typedef Outcome<Error, Model::GetErResult> GetErOutcome;
+			typedef std::future<GetErOutcome> GetErOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetErRequest&, const GetErOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetErAsyncHandler;
+			typedef Outcome<Error, Model::GetErAttachmentResult> GetErAttachmentOutcome;
+			typedef std::future<GetErAttachmentOutcome> GetErAttachmentOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetErAttachmentRequest&, const GetErAttachmentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetErAttachmentAsyncHandler;
+			typedef Outcome<Error, Model::GetErRouteEntryResult> GetErRouteEntryOutcome;
+			typedef std::future<GetErRouteEntryOutcome> GetErRouteEntryOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetErRouteEntryRequest&, const GetErRouteEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetErRouteEntryAsyncHandler;
+			typedef Outcome<Error, Model::GetErRouteMapResult> GetErRouteMapOutcome;
+			typedef std::future<GetErRouteMapOutcome> GetErRouteMapOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetErRouteMapRequest&, const GetErRouteMapOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetErRouteMapAsyncHandler;
+			typedef Outcome<Error, Model::GetFabricTopologyResult> GetFabricTopologyOutcome;
+			typedef std::future<GetFabricTopologyOutcome> GetFabricTopologyOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetFabricTopologyRequest&, const GetFabricTopologyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFabricTopologyAsyncHandler;
+			typedef Outcome<Error, Model::GetLniPrivateIpAddressResult> GetLniPrivateIpAddressOutcome;
+			typedef std::future<GetLniPrivateIpAddressOutcome> GetLniPrivateIpAddressOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetLniPrivateIpAddressRequest&, const GetLniPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLniPrivateIpAddressAsyncHandler;
+			typedef Outcome<Error, Model::GetNetworkInterfaceResult> GetNetworkInterfaceOutcome;
+			typedef std::future<GetNetworkInterfaceOutcome> GetNetworkInterfaceOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetNetworkInterfaceRequest&, const GetNetworkInterfaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNetworkInterfaceAsyncHandler;
+			typedef Outcome<Error, Model::GetNodeInfoForPodResult> GetNodeInfoForPodOutcome;
+			typedef std::future<GetNodeInfoForPodOutcome> GetNodeInfoForPodOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetNodeInfoForPodRequest&, const GetNodeInfoForPodOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNodeInfoForPodAsyncHandler;
 			typedef Outcome<Error, Model::GetSubnetResult> GetSubnetOutcome;
 			typedef std::future<GetSubnetOutcome> GetSubnetOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::GetSubnetRequest&, const GetSubnetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSubnetAsyncHandler;
 			typedef Outcome<Error, Model::GetVccResult> GetVccOutcome;
 			typedef std::future<GetVccOutcome> GetVccOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::GetVccRequest&, const GetVccOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVccAsyncHandler;
+			typedef Outcome<Error, Model::GetVccGrantRuleResult> GetVccGrantRuleOutcome;
+			typedef std::future<GetVccGrantRuleOutcome> GetVccGrantRuleOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetVccGrantRuleRequest&, const GetVccGrantRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVccGrantRuleAsyncHandler;
+			typedef Outcome<Error, Model::GetVccRouteEntryResult> GetVccRouteEntryOutcome;
+			typedef std::future<GetVccRouteEntryOutcome> GetVccRouteEntryOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetVccRouteEntryRequest&, const GetVccRouteEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVccRouteEntryAsyncHandler;
 			typedef Outcome<Error, Model::GetVpdResult> GetVpdOutcome;
 			typedef std::future<GetVpdOutcome> GetVpdOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::GetVpdRequest&, const GetVpdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVpdAsyncHandler;
+			typedef Outcome<Error, Model::GetVpdGrantRuleResult> GetVpdGrantRuleOutcome;
+			typedef std::future<GetVpdGrantRuleOutcome> GetVpdGrantRuleOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetVpdGrantRuleRequest&, const GetVpdGrantRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVpdGrantRuleAsyncHandler;
+			typedef Outcome<Error, Model::GetVpdRouteEntryResult> GetVpdRouteEntryOutcome;
+			typedef std::future<GetVpdRouteEntryOutcome> GetVpdRouteEntryOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetVpdRouteEntryRequest&, const GetVpdRouteEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVpdRouteEntryAsyncHandler;
 			typedef Outcome<Error, Model::InitializeVccResult> InitializeVccOutcome;
 			typedef std::future<InitializeVccOutcome> InitializeVccOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::InitializeVccRequest&, const InitializeVccOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InitializeVccAsyncHandler;
+			typedef Outcome<Error, Model::ListElasticNetworkInterfacesResult> ListElasticNetworkInterfacesOutcome;
+			typedef std::future<ListElasticNetworkInterfacesOutcome> ListElasticNetworkInterfacesOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListElasticNetworkInterfacesRequest&, const ListElasticNetworkInterfacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListElasticNetworkInterfacesAsyncHandler;
+			typedef Outcome<Error, Model::ListErAttachmentsResult> ListErAttachmentsOutcome;
+			typedef std::future<ListErAttachmentsOutcome> ListErAttachmentsOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListErAttachmentsRequest&, const ListErAttachmentsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListErAttachmentsAsyncHandler;
+			typedef Outcome<Error, Model::ListErRouteEntriesResult> ListErRouteEntriesOutcome;
+			typedef std::future<ListErRouteEntriesOutcome> ListErRouteEntriesOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListErRouteEntriesRequest&, const ListErRouteEntriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListErRouteEntriesAsyncHandler;
+			typedef Outcome<Error, Model::ListErRouteMapsResult> ListErRouteMapsOutcome;
+			typedef std::future<ListErRouteMapsOutcome> ListErRouteMapsOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListErRouteMapsRequest&, const ListErRouteMapsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListErRouteMapsAsyncHandler;
+			typedef Outcome<Error, Model::ListErsResult> ListErsOutcome;
+			typedef std::future<ListErsOutcome> ListErsOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListErsRequest&, const ListErsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListErsAsyncHandler;
+			typedef Outcome<Error, Model::ListInstancesByNcdResult> ListInstancesByNcdOutcome;
+			typedef std::future<ListInstancesByNcdOutcome> ListInstancesByNcdOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListInstancesByNcdRequest&, const ListInstancesByNcdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInstancesByNcdAsyncHandler;
+			typedef Outcome<Error, Model::ListLniPrivateIpAddressResult> ListLniPrivateIpAddressOutcome;
+			typedef std::future<ListLniPrivateIpAddressOutcome> ListLniPrivateIpAddressOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListLniPrivateIpAddressRequest&, const ListLniPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListLniPrivateIpAddressAsyncHandler;
+			typedef Outcome<Error, Model::ListNetworkInterfacesResult> ListNetworkInterfacesOutcome;
+			typedef std::future<ListNetworkInterfacesOutcome> ListNetworkInterfacesOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListNetworkInterfacesRequest&, const ListNetworkInterfacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListNetworkInterfacesAsyncHandler;
+			typedef Outcome<Error, Model::ListNodeInfosForPodResult> ListNodeInfosForPodOutcome;
+			typedef std::future<ListNodeInfosForPodOutcome> ListNodeInfosForPodOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListNodeInfosForPodRequest&, const ListNodeInfosForPodOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListNodeInfosForPodAsyncHandler;
 			typedef Outcome<Error, Model::ListSubnetsResult> ListSubnetsOutcome;
 			typedef std::future<ListSubnetsOutcome> ListSubnetsOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::ListSubnetsRequest&, const ListSubnetsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSubnetsAsyncHandler;
+			typedef Outcome<Error, Model::ListVccGrantRulesResult> ListVccGrantRulesOutcome;
+			typedef std::future<ListVccGrantRulesOutcome> ListVccGrantRulesOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListVccGrantRulesRequest&, const ListVccGrantRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVccGrantRulesAsyncHandler;
+			typedef Outcome<Error, Model::ListVccRouteEntriesResult> ListVccRouteEntriesOutcome;
+			typedef std::future<ListVccRouteEntriesOutcome> ListVccRouteEntriesOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListVccRouteEntriesRequest&, const ListVccRouteEntriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVccRouteEntriesAsyncHandler;
 			typedef Outcome<Error, Model::ListVccsResult> ListVccsOutcome;
 			typedef std::future<ListVccsOutcome> ListVccsOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::ListVccsRequest&, const ListVccsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVccsAsyncHandler;
+			typedef Outcome<Error, Model::ListVpdGrantRulesResult> ListVpdGrantRulesOutcome;
+			typedef std::future<ListVpdGrantRulesOutcome> ListVpdGrantRulesOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListVpdGrantRulesRequest&, const ListVpdGrantRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpdGrantRulesAsyncHandler;
+			typedef Outcome<Error, Model::ListVpdRouteEntriesResult> ListVpdRouteEntriesOutcome;
+			typedef std::future<ListVpdRouteEntriesOutcome> ListVpdRouteEntriesOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListVpdRouteEntriesRequest&, const ListVpdRouteEntriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpdRouteEntriesAsyncHandler;
 			typedef Outcome<Error, Model::ListVpdsResult> ListVpdsOutcome;
 			typedef std::future<ListVpdsOutcome> ListVpdsOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::ListVpdsRequest&, const ListVpdsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpdsAsyncHandler;
+			typedef Outcome<Error, Model::QueryInstanceNcdResult> QueryInstanceNcdOutcome;
+			typedef std::future<QueryInstanceNcdOutcome> QueryInstanceNcdOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::QueryInstanceNcdRequest&, const QueryInstanceNcdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryInstanceNcdAsyncHandler;
+			typedef Outcome<Error, Model::UnAssignPrivateIpAddressResult> UnAssignPrivateIpAddressOutcome;
+			typedef std::future<UnAssignPrivateIpAddressOutcome> UnAssignPrivateIpAddressOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::UnAssignPrivateIpAddressRequest&, const UnAssignPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnAssignPrivateIpAddressAsyncHandler;
+			typedef Outcome<Error, Model::UnAssociateVpdCidrBlockResult> UnAssociateVpdCidrBlockOutcome;
+			typedef std::future<UnAssociateVpdCidrBlockOutcome> UnAssociateVpdCidrBlockOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::UnAssociateVpdCidrBlockRequest&, const UnAssociateVpdCidrBlockOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnAssociateVpdCidrBlockAsyncHandler;
+			typedef Outcome<Error, Model::UpdateElasticNetworkInterfaceResult> UpdateElasticNetworkInterfaceOutcome;
+			typedef std::future<UpdateElasticNetworkInterfaceOutcome> UpdateElasticNetworkInterfaceOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::UpdateElasticNetworkInterfaceRequest&, const UpdateElasticNetworkInterfaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateElasticNetworkInterfaceAsyncHandler;
+			typedef Outcome<Error, Model::UpdateErResult> UpdateErOutcome;
+			typedef std::future<UpdateErOutcome> UpdateErOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::UpdateErRequest&, const UpdateErOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateErAsyncHandler;
+			typedef Outcome<Error, Model::UpdateErAttachmentResult> UpdateErAttachmentOutcome;
+			typedef std::future<UpdateErAttachmentOutcome> UpdateErAttachmentOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::UpdateErAttachmentRequest&, const UpdateErAttachmentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateErAttachmentAsyncHandler;
+			typedef Outcome<Error, Model::UpdateErRouteMapResult> UpdateErRouteMapOutcome;
+			typedef std::future<UpdateErRouteMapOutcome> UpdateErRouteMapOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::UpdateErRouteMapRequest&, const UpdateErRouteMapOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateErRouteMapAsyncHandler;
 			typedef Outcome<Error, Model::UpdateSubnetResult> UpdateSubnetOutcome;
 			typedef std::future<UpdateSubnetOutcome> UpdateSubnetOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::UpdateSubnetRequest&, const UpdateSubnetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateSubnetAsyncHandler;
@@ -111,42 +361,192 @@ namespace AlibabaCloud
 			EfloClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			EfloClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~EfloClient();
+			AssignPrivateIpAddressOutcome assignPrivateIpAddress(const Model::AssignPrivateIpAddressRequest &request)const;
+			void assignPrivateIpAddressAsync(const Model::AssignPrivateIpAddressRequest& request, const AssignPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AssignPrivateIpAddressOutcomeCallable assignPrivateIpAddressCallable(const Model::AssignPrivateIpAddressRequest& request) const;
+			AssociateVpdCidrBlockOutcome associateVpdCidrBlock(const Model::AssociateVpdCidrBlockRequest &request)const;
+			void associateVpdCidrBlockAsync(const Model::AssociateVpdCidrBlockRequest& request, const AssociateVpdCidrBlockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AssociateVpdCidrBlockOutcomeCallable associateVpdCidrBlockCallable(const Model::AssociateVpdCidrBlockRequest& request) const;
+			CreateElasticNetworkInterfaceOutcome createElasticNetworkInterface(const Model::CreateElasticNetworkInterfaceRequest &request)const;
+			void createElasticNetworkInterfaceAsync(const Model::CreateElasticNetworkInterfaceRequest& request, const CreateElasticNetworkInterfaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateElasticNetworkInterfaceOutcomeCallable createElasticNetworkInterfaceCallable(const Model::CreateElasticNetworkInterfaceRequest& request) const;
+			CreateErOutcome createEr(const Model::CreateErRequest &request)const;
+			void createErAsync(const Model::CreateErRequest& request, const CreateErAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateErOutcomeCallable createErCallable(const Model::CreateErRequest& request) const;
+			CreateErAttachmentOutcome createErAttachment(const Model::CreateErAttachmentRequest &request)const;
+			void createErAttachmentAsync(const Model::CreateErAttachmentRequest& request, const CreateErAttachmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateErAttachmentOutcomeCallable createErAttachmentCallable(const Model::CreateErAttachmentRequest& request) const;
+			CreateErRouteMapOutcome createErRouteMap(const Model::CreateErRouteMapRequest &request)const;
+			void createErRouteMapAsync(const Model::CreateErRouteMapRequest& request, const CreateErRouteMapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateErRouteMapOutcomeCallable createErRouteMapCallable(const Model::CreateErRouteMapRequest& request) const;
 			CreateSubnetOutcome createSubnet(const Model::CreateSubnetRequest &request)const;
 			void createSubnetAsync(const Model::CreateSubnetRequest& request, const CreateSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateSubnetOutcomeCallable createSubnetCallable(const Model::CreateSubnetRequest& request) const;
 			CreateVccOutcome createVcc(const Model::CreateVccRequest &request)const;
 			void createVccAsync(const Model::CreateVccRequest& request, const CreateVccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateVccOutcomeCallable createVccCallable(const Model::CreateVccRequest& request) const;
+			CreateVccGrantRuleOutcome createVccGrantRule(const Model::CreateVccGrantRuleRequest &request)const;
+			void createVccGrantRuleAsync(const Model::CreateVccGrantRuleRequest& request, const CreateVccGrantRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateVccGrantRuleOutcomeCallable createVccGrantRuleCallable(const Model::CreateVccGrantRuleRequest& request) const;
+			CreateVccRouteEntryOutcome createVccRouteEntry(const Model::CreateVccRouteEntryRequest &request)const;
+			void createVccRouteEntryAsync(const Model::CreateVccRouteEntryRequest& request, const CreateVccRouteEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateVccRouteEntryOutcomeCallable createVccRouteEntryCallable(const Model::CreateVccRouteEntryRequest& request) const;
 			CreateVpdOutcome createVpd(const Model::CreateVpdRequest &request)const;
 			void createVpdAsync(const Model::CreateVpdRequest& request, const CreateVpdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateVpdOutcomeCallable createVpdCallable(const Model::CreateVpdRequest& request) const;
+			CreateVpdGrantRuleOutcome createVpdGrantRule(const Model::CreateVpdGrantRuleRequest &request)const;
+			void createVpdGrantRuleAsync(const Model::CreateVpdGrantRuleRequest& request, const CreateVpdGrantRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateVpdGrantRuleOutcomeCallable createVpdGrantRuleCallable(const Model::CreateVpdGrantRuleRequest& request) const;
+			DeleteElasticNetworkInterfaceOutcome deleteElasticNetworkInterface(const Model::DeleteElasticNetworkInterfaceRequest &request)const;
+			void deleteElasticNetworkInterfaceAsync(const Model::DeleteElasticNetworkInterfaceRequest& request, const DeleteElasticNetworkInterfaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteElasticNetworkInterfaceOutcomeCallable deleteElasticNetworkInterfaceCallable(const Model::DeleteElasticNetworkInterfaceRequest& request) const;
+			DeleteErOutcome deleteEr(const Model::DeleteErRequest &request)const;
+			void deleteErAsync(const Model::DeleteErRequest& request, const DeleteErAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteErOutcomeCallable deleteErCallable(const Model::DeleteErRequest& request) const;
+			DeleteErAttachmentOutcome deleteErAttachment(const Model::DeleteErAttachmentRequest &request)const;
+			void deleteErAttachmentAsync(const Model::DeleteErAttachmentRequest& request, const DeleteErAttachmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteErAttachmentOutcomeCallable deleteErAttachmentCallable(const Model::DeleteErAttachmentRequest& request) const;
+			DeleteErRouteMapOutcome deleteErRouteMap(const Model::DeleteErRouteMapRequest &request)const;
+			void deleteErRouteMapAsync(const Model::DeleteErRouteMapRequest& request, const DeleteErRouteMapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteErRouteMapOutcomeCallable deleteErRouteMapCallable(const Model::DeleteErRouteMapRequest& request) const;
 			DeleteSubnetOutcome deleteSubnet(const Model::DeleteSubnetRequest &request)const;
 			void deleteSubnetAsync(const Model::DeleteSubnetRequest& request, const DeleteSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteSubnetOutcomeCallable deleteSubnetCallable(const Model::DeleteSubnetRequest& request) const;
+			DeleteVccGrantRuleOutcome deleteVccGrantRule(const Model::DeleteVccGrantRuleRequest &request)const;
+			void deleteVccGrantRuleAsync(const Model::DeleteVccGrantRuleRequest& request, const DeleteVccGrantRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteVccGrantRuleOutcomeCallable deleteVccGrantRuleCallable(const Model::DeleteVccGrantRuleRequest& request) const;
+			DeleteVccRouteEntryOutcome deleteVccRouteEntry(const Model::DeleteVccRouteEntryRequest &request)const;
+			void deleteVccRouteEntryAsync(const Model::DeleteVccRouteEntryRequest& request, const DeleteVccRouteEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteVccRouteEntryOutcomeCallable deleteVccRouteEntryCallable(const Model::DeleteVccRouteEntryRequest& request) const;
 			DeleteVpdOutcome deleteVpd(const Model::DeleteVpdRequest &request)const;
 			void deleteVpdAsync(const Model::DeleteVpdRequest& request, const DeleteVpdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteVpdOutcomeCallable deleteVpdCallable(const Model::DeleteVpdRequest& request) const;
+			DeleteVpdGrantRuleOutcome deleteVpdGrantRule(const Model::DeleteVpdGrantRuleRequest &request)const;
+			void deleteVpdGrantRuleAsync(const Model::DeleteVpdGrantRuleRequest& request, const DeleteVpdGrantRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteVpdGrantRuleOutcomeCallable deleteVpdGrantRuleCallable(const Model::DeleteVpdGrantRuleRequest& request) const;
+			DescribeSlrOutcome describeSlr(const Model::DescribeSlrRequest &request)const;
+			void describeSlrAsync(const Model::DescribeSlrRequest& request, const DescribeSlrAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSlrOutcomeCallable describeSlrCallable(const Model::DescribeSlrRequest& request) const;
+			GetElasticNetworkInterfaceOutcome getElasticNetworkInterface(const Model::GetElasticNetworkInterfaceRequest &request)const;
+			void getElasticNetworkInterfaceAsync(const Model::GetElasticNetworkInterfaceRequest& request, const GetElasticNetworkInterfaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetElasticNetworkInterfaceOutcomeCallable getElasticNetworkInterfaceCallable(const Model::GetElasticNetworkInterfaceRequest& request) const;
+			GetErOutcome getEr(const Model::GetErRequest &request)const;
+			void getErAsync(const Model::GetErRequest& request, const GetErAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetErOutcomeCallable getErCallable(const Model::GetErRequest& request) const;
+			GetErAttachmentOutcome getErAttachment(const Model::GetErAttachmentRequest &request)const;
+			void getErAttachmentAsync(const Model::GetErAttachmentRequest& request, const GetErAttachmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetErAttachmentOutcomeCallable getErAttachmentCallable(const Model::GetErAttachmentRequest& request) const;
+			GetErRouteEntryOutcome getErRouteEntry(const Model::GetErRouteEntryRequest &request)const;
+			void getErRouteEntryAsync(const Model::GetErRouteEntryRequest& request, const GetErRouteEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetErRouteEntryOutcomeCallable getErRouteEntryCallable(const Model::GetErRouteEntryRequest& request) const;
+			GetErRouteMapOutcome getErRouteMap(const Model::GetErRouteMapRequest &request)const;
+			void getErRouteMapAsync(const Model::GetErRouteMapRequest& request, const GetErRouteMapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetErRouteMapOutcomeCallable getErRouteMapCallable(const Model::GetErRouteMapRequest& request) const;
+			GetFabricTopologyOutcome getFabricTopology(const Model::GetFabricTopologyRequest &request)const;
+			void getFabricTopologyAsync(const Model::GetFabricTopologyRequest& request, const GetFabricTopologyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetFabricTopologyOutcomeCallable getFabricTopologyCallable(const Model::GetFabricTopologyRequest& request) const;
+			GetLniPrivateIpAddressOutcome getLniPrivateIpAddress(const Model::GetLniPrivateIpAddressRequest &request)const;
+			void getLniPrivateIpAddressAsync(const Model::GetLniPrivateIpAddressRequest& request, const GetLniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetLniPrivateIpAddressOutcomeCallable getLniPrivateIpAddressCallable(const Model::GetLniPrivateIpAddressRequest& request) const;
+			GetNetworkInterfaceOutcome getNetworkInterface(const Model::GetNetworkInterfaceRequest &request)const;
+			void getNetworkInterfaceAsync(const Model::GetNetworkInterfaceRequest& request, const GetNetworkInterfaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetNetworkInterfaceOutcomeCallable getNetworkInterfaceCallable(const Model::GetNetworkInterfaceRequest& request) const;
+			GetNodeInfoForPodOutcome getNodeInfoForPod(const Model::GetNodeInfoForPodRequest &request)const;
+			void getNodeInfoForPodAsync(const Model::GetNodeInfoForPodRequest& request, const GetNodeInfoForPodAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetNodeInfoForPodOutcomeCallable getNodeInfoForPodCallable(const Model::GetNodeInfoForPodRequest& request) const;
 			GetSubnetOutcome getSubnet(const Model::GetSubnetRequest &request)const;
 			void getSubnetAsync(const Model::GetSubnetRequest& request, const GetSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetSubnetOutcomeCallable getSubnetCallable(const Model::GetSubnetRequest& request) const;
 			GetVccOutcome getVcc(const Model::GetVccRequest &request)const;
 			void getVccAsync(const Model::GetVccRequest& request, const GetVccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetVccOutcomeCallable getVccCallable(const Model::GetVccRequest& request) const;
+			GetVccGrantRuleOutcome getVccGrantRule(const Model::GetVccGrantRuleRequest &request)const;
+			void getVccGrantRuleAsync(const Model::GetVccGrantRuleRequest& request, const GetVccGrantRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVccGrantRuleOutcomeCallable getVccGrantRuleCallable(const Model::GetVccGrantRuleRequest& request) const;
+			GetVccRouteEntryOutcome getVccRouteEntry(const Model::GetVccRouteEntryRequest &request)const;
+			void getVccRouteEntryAsync(const Model::GetVccRouteEntryRequest& request, const GetVccRouteEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVccRouteEntryOutcomeCallable getVccRouteEntryCallable(const Model::GetVccRouteEntryRequest& request) const;
 			GetVpdOutcome getVpd(const Model::GetVpdRequest &request)const;
 			void getVpdAsync(const Model::GetVpdRequest& request, const GetVpdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetVpdOutcomeCallable getVpdCallable(const Model::GetVpdRequest& request) const;
+			GetVpdGrantRuleOutcome getVpdGrantRule(const Model::GetVpdGrantRuleRequest &request)const;
+			void getVpdGrantRuleAsync(const Model::GetVpdGrantRuleRequest& request, const GetVpdGrantRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVpdGrantRuleOutcomeCallable getVpdGrantRuleCallable(const Model::GetVpdGrantRuleRequest& request) const;
+			GetVpdRouteEntryOutcome getVpdRouteEntry(const Model::GetVpdRouteEntryRequest &request)const;
+			void getVpdRouteEntryAsync(const Model::GetVpdRouteEntryRequest& request, const GetVpdRouteEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVpdRouteEntryOutcomeCallable getVpdRouteEntryCallable(const Model::GetVpdRouteEntryRequest& request) const;
 			InitializeVccOutcome initializeVcc(const Model::InitializeVccRequest &request)const;
 			void initializeVccAsync(const Model::InitializeVccRequest& request, const InitializeVccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			InitializeVccOutcomeCallable initializeVccCallable(const Model::InitializeVccRequest& request) const;
+			ListElasticNetworkInterfacesOutcome listElasticNetworkInterfaces(const Model::ListElasticNetworkInterfacesRequest &request)const;
+			void listElasticNetworkInterfacesAsync(const Model::ListElasticNetworkInterfacesRequest& request, const ListElasticNetworkInterfacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListElasticNetworkInterfacesOutcomeCallable listElasticNetworkInterfacesCallable(const Model::ListElasticNetworkInterfacesRequest& request) const;
+			ListErAttachmentsOutcome listErAttachments(const Model::ListErAttachmentsRequest &request)const;
+			void listErAttachmentsAsync(const Model::ListErAttachmentsRequest& request, const ListErAttachmentsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListErAttachmentsOutcomeCallable listErAttachmentsCallable(const Model::ListErAttachmentsRequest& request) const;
+			ListErRouteEntriesOutcome listErRouteEntries(const Model::ListErRouteEntriesRequest &request)const;
+			void listErRouteEntriesAsync(const Model::ListErRouteEntriesRequest& request, const ListErRouteEntriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListErRouteEntriesOutcomeCallable listErRouteEntriesCallable(const Model::ListErRouteEntriesRequest& request) const;
+			ListErRouteMapsOutcome listErRouteMaps(const Model::ListErRouteMapsRequest &request)const;
+			void listErRouteMapsAsync(const Model::ListErRouteMapsRequest& request, const ListErRouteMapsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListErRouteMapsOutcomeCallable listErRouteMapsCallable(const Model::ListErRouteMapsRequest& request) const;
+			ListErsOutcome listErs(const Model::ListErsRequest &request)const;
+			void listErsAsync(const Model::ListErsRequest& request, const ListErsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListErsOutcomeCallable listErsCallable(const Model::ListErsRequest& request) const;
+			ListInstancesByNcdOutcome listInstancesByNcd(const Model::ListInstancesByNcdRequest &request)const;
+			void listInstancesByNcdAsync(const Model::ListInstancesByNcdRequest& request, const ListInstancesByNcdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListInstancesByNcdOutcomeCallable listInstancesByNcdCallable(const Model::ListInstancesByNcdRequest& request) const;
+			ListLniPrivateIpAddressOutcome listLniPrivateIpAddress(const Model::ListLniPrivateIpAddressRequest &request)const;
+			void listLniPrivateIpAddressAsync(const Model::ListLniPrivateIpAddressRequest& request, const ListLniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListLniPrivateIpAddressOutcomeCallable listLniPrivateIpAddressCallable(const Model::ListLniPrivateIpAddressRequest& request) const;
+			ListNetworkInterfacesOutcome listNetworkInterfaces(const Model::ListNetworkInterfacesRequest &request)const;
+			void listNetworkInterfacesAsync(const Model::ListNetworkInterfacesRequest& request, const ListNetworkInterfacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListNetworkInterfacesOutcomeCallable listNetworkInterfacesCallable(const Model::ListNetworkInterfacesRequest& request) const;
+			ListNodeInfosForPodOutcome listNodeInfosForPod(const Model::ListNodeInfosForPodRequest &request)const;
+			void listNodeInfosForPodAsync(const Model::ListNodeInfosForPodRequest& request, const ListNodeInfosForPodAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListNodeInfosForPodOutcomeCallable listNodeInfosForPodCallable(const Model::ListNodeInfosForPodRequest& request) const;
 			ListSubnetsOutcome listSubnets(const Model::ListSubnetsRequest &request)const;
 			void listSubnetsAsync(const Model::ListSubnetsRequest& request, const ListSubnetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListSubnetsOutcomeCallable listSubnetsCallable(const Model::ListSubnetsRequest& request) const;
+			ListVccGrantRulesOutcome listVccGrantRules(const Model::ListVccGrantRulesRequest &request)const;
+			void listVccGrantRulesAsync(const Model::ListVccGrantRulesRequest& request, const ListVccGrantRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVccGrantRulesOutcomeCallable listVccGrantRulesCallable(const Model::ListVccGrantRulesRequest& request) const;
+			ListVccRouteEntriesOutcome listVccRouteEntries(const Model::ListVccRouteEntriesRequest &request)const;
+			void listVccRouteEntriesAsync(const Model::ListVccRouteEntriesRequest& request, const ListVccRouteEntriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVccRouteEntriesOutcomeCallable listVccRouteEntriesCallable(const Model::ListVccRouteEntriesRequest& request) const;
 			ListVccsOutcome listVccs(const Model::ListVccsRequest &request)const;
 			void listVccsAsync(const Model::ListVccsRequest& request, const ListVccsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListVccsOutcomeCallable listVccsCallable(const Model::ListVccsRequest& request) const;
+			ListVpdGrantRulesOutcome listVpdGrantRules(const Model::ListVpdGrantRulesRequest &request)const;
+			void listVpdGrantRulesAsync(const Model::ListVpdGrantRulesRequest& request, const ListVpdGrantRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVpdGrantRulesOutcomeCallable listVpdGrantRulesCallable(const Model::ListVpdGrantRulesRequest& request) const;
+			ListVpdRouteEntriesOutcome listVpdRouteEntries(const Model::ListVpdRouteEntriesRequest &request)const;
+			void listVpdRouteEntriesAsync(const Model::ListVpdRouteEntriesRequest& request, const ListVpdRouteEntriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVpdRouteEntriesOutcomeCallable listVpdRouteEntriesCallable(const Model::ListVpdRouteEntriesRequest& request) const;
 			ListVpdsOutcome listVpds(const Model::ListVpdsRequest &request)const;
 			void listVpdsAsync(const Model::ListVpdsRequest& request, const ListVpdsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListVpdsOutcomeCallable listVpdsCallable(const Model::ListVpdsRequest& request) const;
+			QueryInstanceNcdOutcome queryInstanceNcd(const Model::QueryInstanceNcdRequest &request)const;
+			void queryInstanceNcdAsync(const Model::QueryInstanceNcdRequest& request, const QueryInstanceNcdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryInstanceNcdOutcomeCallable queryInstanceNcdCallable(const Model::QueryInstanceNcdRequest& request) const;
+			UnAssignPrivateIpAddressOutcome unAssignPrivateIpAddress(const Model::UnAssignPrivateIpAddressRequest &request)const;
+			void unAssignPrivateIpAddressAsync(const Model::UnAssignPrivateIpAddressRequest& request, const UnAssignPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UnAssignPrivateIpAddressOutcomeCallable unAssignPrivateIpAddressCallable(const Model::UnAssignPrivateIpAddressRequest& request) const;
+			UnAssociateVpdCidrBlockOutcome unAssociateVpdCidrBlock(const Model::UnAssociateVpdCidrBlockRequest &request)const;
+			void unAssociateVpdCidrBlockAsync(const Model::UnAssociateVpdCidrBlockRequest& request, const UnAssociateVpdCidrBlockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UnAssociateVpdCidrBlockOutcomeCallable unAssociateVpdCidrBlockCallable(const Model::UnAssociateVpdCidrBlockRequest& request) const;
+			UpdateElasticNetworkInterfaceOutcome updateElasticNetworkInterface(const Model::UpdateElasticNetworkInterfaceRequest &request)const;
+			void updateElasticNetworkInterfaceAsync(const Model::UpdateElasticNetworkInterfaceRequest& request, const UpdateElasticNetworkInterfaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateElasticNetworkInterfaceOutcomeCallable updateElasticNetworkInterfaceCallable(const Model::UpdateElasticNetworkInterfaceRequest& request) const;
+			UpdateErOutcome updateEr(const Model::UpdateErRequest &request)const;
+			void updateErAsync(const Model::UpdateErRequest& request, const UpdateErAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateErOutcomeCallable updateErCallable(const Model::UpdateErRequest& request) const;
+			UpdateErAttachmentOutcome updateErAttachment(const Model::UpdateErAttachmentRequest &request)const;
+			void updateErAttachmentAsync(const Model::UpdateErAttachmentRequest& request, const UpdateErAttachmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateErAttachmentOutcomeCallable updateErAttachmentCallable(const Model::UpdateErAttachmentRequest& request) const;
+			UpdateErRouteMapOutcome updateErRouteMap(const Model::UpdateErRouteMapRequest &request)const;
+			void updateErRouteMapAsync(const Model::UpdateErRouteMapRequest& request, const UpdateErRouteMapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateErRouteMapOutcomeCallable updateErRouteMapCallable(const Model::UpdateErRouteMapRequest& request) const;
 			UpdateSubnetOutcome updateSubnet(const Model::UpdateSubnetRequest &request)const;
 			void updateSubnetAsync(const Model::UpdateSubnetRequest& request, const UpdateSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateSubnetOutcomeCallable updateSubnetCallable(const Model::UpdateSubnetRequest& request) const;

eflo/include/alibabacloud/eflo/model/AssignPrivateIpAddressRequest.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_EFLO_MODEL_ASSIGNPRIVATEIPADDRESSREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_ASSIGNPRIVATEIPADDRESSREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT AssignPrivateIpAddressRequest : public RpcServiceRequest {
+public:
+	AssignPrivateIpAddressRequest();
+	~AssignPrivateIpAddressRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	bool getAssignMac() const;
+	void setAssignMac(bool assignMac);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getSubnetId() const;
+	void setSubnetId(const std::string &subnetId);
+	bool getSkipConfig() const;
+	void setSkipConfig(bool skipConfig);
+	std::string getPrivateIpAddress() const;
+	void setPrivateIpAddress(const std::string &privateIpAddress);
+	std::string getNetworkInterfaceId() const;
+	void setNetworkInterfaceId(const std::string &networkInterfaceId);
+
+private:
+	std::string description_;
+	bool assignMac_;
+	std::string regionId_;
+	std::string subnetId_;
+	bool skipConfig_;
+	std::string privateIpAddress_;
+	std::string networkInterfaceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_ASSIGNPRIVATEIPADDRESSREQUEST_H_

eflo/include/alibabacloud/eflo/model/AssignPrivateIpAddressResult.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_EFLO_MODEL_ASSIGNPRIVATEIPADDRESSRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_ASSIGNPRIVATEIPADDRESSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eflo/EfloExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eflo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EFLO_EXPORT AssignPrivateIpAddressResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string ipName;
+					std::string networkInterfaceId;
+				};
+
+
+				AssignPrivateIpAddressResult();
+				explicit AssignPrivateIpAddressResult(const std::string &payload);
+				~AssignPrivateIpAddressResult();
+				std::string getMessage()const;
+				Content getContent()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Content content_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EFLO_MODEL_ASSIGNPRIVATEIPADDRESSRESULT_H_

eflo/include/alibabacloud/eflo/model/AssociateVpdCidrBlockRequest.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_EFLO_MODEL_ASSOCIATEVPDCIDRBLOCKREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_ASSOCIATEVPDCIDRBLOCKREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT AssociateVpdCidrBlockRequest : public RpcServiceRequest {
+public:
+	AssociateVpdCidrBlockRequest();
+	~AssociateVpdCidrBlockRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getVpdId() const;
+	void setVpdId(const std::string &vpdId);
+	std::string getSecondaryCidrBlock() const;
+	void setSecondaryCidrBlock(const std::string &secondaryCidrBlock);
+
+private:
+	std::string regionId_;
+	std::string vpdId_;
+	std::string secondaryCidrBlock_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_ASSOCIATEVPDCIDRBLOCKREQUEST_H_

eflo/include/alibabacloud/eflo/model/AssociateVpdCidrBlockResult.h

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

eflo/include/alibabacloud/eflo/model/CreateElasticNetworkInterfaceRequest.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_EFLO_MODEL_CREATEELASTICNETWORKINTERFACEREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEELASTICNETWORKINTERFACEREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT CreateElasticNetworkInterfaceRequest : public RpcServiceRequest {
+public:
+	CreateElasticNetworkInterfaceRequest();
+	~CreateElasticNetworkInterfaceRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	std::string getNodeId() const;
+	void setNodeId(const std::string &nodeId);
+
+private:
+	std::string description_;
+	std::string vSwitchId_;
+	std::string regionId_;
+	std::string vpcId_;
+	std::string zoneId_;
+	std::string nodeId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEELASTICNETWORKINTERFACEREQUEST_H_

eflo/include/alibabacloud/eflo/model/CreateElasticNetworkInterfaceResult.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_EFLO_MODEL_CREATEELASTICNETWORKINTERFACERESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEELASTICNETWORKINTERFACERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eflo/EfloExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eflo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EFLO_EXPORT CreateElasticNetworkInterfaceResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string elasticNetworkInterfaceId;
+					std::string nodeId;
+				};
+
+
+				CreateElasticNetworkInterfaceResult();
+				explicit CreateElasticNetworkInterfaceResult(const std::string &payload);
+				~CreateElasticNetworkInterfaceResult();
+				std::string getMessage()const;
+				Content getContent()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Content content_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEELASTICNETWORKINTERFACERESULT_H_

eflo/include/alibabacloud/eflo/model/CreateErAttachmentRequest.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_EFLO_MODEL_CREATEERATTACHMENTREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEERATTACHMENTREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT CreateErAttachmentRequest : public RpcServiceRequest {
+public:
+	CreateErAttachmentRequest();
+	~CreateErAttachmentRequest();
+	std::string getResourceTenantId() const;
+	void setResourceTenantId(const std::string &resourceTenantId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getAutoReceiveAllRoute() const;
+	void setAutoReceiveAllRoute(bool autoReceiveAllRoute);
+	std::string getInstanceType() const;
+	void setInstanceType(const std::string &instanceType);
+	std::string getErAttachmentName() const;
+	void setErAttachmentName(const std::string &erAttachmentName);
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+
+private:
+	std::string resourceTenantId_;
+	std::string regionId_;
+	bool autoReceiveAllRoute_;
+	std::string instanceType_;
+	std::string erAttachmentName_;
+	std::string erId_;
+	std::string instanceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEERATTACHMENTREQUEST_H_

eflo/include/alibabacloud/eflo/model/CreateErAttachmentResult.h

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

eflo/include/alibabacloud/eflo/model/CreateErRequest.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_EFLO_MODEL_CREATEERREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEERREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT CreateErRequest : public RpcServiceRequest {
+public:
+	CreateErRequest();
+	~CreateErRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getErName() const;
+	void setErName(const std::string &erName);
+	std::string getMasterZoneId() const;
+	void setMasterZoneId(const std::string &masterZoneId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string description_;
+	std::string erName_;
+	std::string masterZoneId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEERREQUEST_H_

eflo/include/alibabacloud/eflo/model/CreateErResult.h

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

eflo/include/alibabacloud/eflo/model/CreateErRouteMapRequest.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_EFLO_MODEL_CREATEERROUTEMAPREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEERROUTEMAPREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT CreateErRouteMapRequest : public RpcServiceRequest {
+public:
+	CreateErRouteMapRequest();
+	~CreateErRouteMapRequest();
+	std::string getReceptionInstanceType() const;
+	void setReceptionInstanceType(const std::string &receptionInstanceType);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getReceptionInstanceId() const;
+	void setReceptionInstanceId(const std::string &receptionInstanceId);
+	std::string getRouteMapAction() const;
+	void setRouteMapAction(const std::string &routeMapAction);
+	std::string getTransmissionInstanceType() const;
+	void setTransmissionInstanceType(const std::string &transmissionInstanceType);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDestinationCidrBlock() const;
+	void setDestinationCidrBlock(const std::string &destinationCidrBlock);
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	int getRouteMapNum() const;
+	void setRouteMapNum(int routeMapNum);
+	std::string getReceptionInstanceOwner() const;
+	void setReceptionInstanceOwner(const std::string &receptionInstanceOwner);
+	std::string getTransmissionInstanceOwner() const;
+	void setTransmissionInstanceOwner(const std::string &transmissionInstanceOwner);
+	std::string getTransmissionInstanceId() const;
+	void setTransmissionInstanceId(const std::string &transmissionInstanceId);
+
+private:
+	std::string receptionInstanceType_;
+	std::string description_;
+	std::string receptionInstanceId_;
+	std::string routeMapAction_;
+	std::string transmissionInstanceType_;
+	std::string regionId_;
+	std::string destinationCidrBlock_;
+	std::string erId_;
+	int routeMapNum_;
+	std::string receptionInstanceOwner_;
+	std::string transmissionInstanceOwner_;
+	std::string transmissionInstanceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEERROUTEMAPREQUEST_H_

eflo/include/alibabacloud/eflo/model/CreateErRouteMapResult.h

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

eflo/include/alibabacloud/eflo/model/CreateSubnetRequest.h

@@ -28,28 +28,35 @@ namespace Eflo {
 namespace Model {
 class ALIBABACLOUD_EFLO_EXPORT CreateSubnetRequest : public RpcServiceRequest {
 public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
 	CreateSubnetRequest();
 	~CreateSubnetRequest();
 	std::string getType() const;
 	void setType(const std::string &type);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
-	std::string getVpdId() const;
-	void setVpdId(const std::string &vpdId);
-	std::string getName() const;
-	void setName(const std::string &name);
-	std::string getZoneId() const;
-	void setZoneId(const std::string &zoneId);
 	std::string getCidr() const;
 	void setCidr(const std::string &cidr);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::string getVpdId() const;
+	void setVpdId(const std::string &vpdId);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	std::string getSubnetName() const;
+	void setSubnetName(const std::string &subnetName);
 
 private:
 	std::string type_;
 	std::string regionId_;
-	std::string vpdId_;
-	std::string name_;
-	std::string zoneId_;
 	std::string cidr_;
+	std::vector<Tag> tag_;
+	std::string vpdId_;
+	std::string zoneId_;
+	std::string subnetName_;
 };
 } // namespace Model
 } // namespace Eflo

eflo/include/alibabacloud/eflo/model/CreateVccGrantRuleRequest.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_EFLO_MODEL_CREATEVCCGRANTRULEREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEVCCGRANTRULEREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT CreateVccGrantRuleRequest : public RpcServiceRequest {
+public:
+	CreateVccGrantRuleRequest();
+	~CreateVccGrantRuleRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getGrantTenantId() const;
+	void setGrantTenantId(const std::string &grantTenantId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string erId_;
+	std::string grantTenantId_;
+	std::string instanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEVCCGRANTRULEREQUEST_H_

eflo/include/alibabacloud/eflo/model/CreateVccGrantRuleResult.h

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

eflo/include/alibabacloud/eflo/model/CreateVccRequest.h

@@ -28,6 +28,10 @@ namespace Eflo {
 namespace Model {
 class ALIBABACLOUD_EFLO_EXPORT CreateVccRequest : public RpcServiceRequest {
 public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
 	CreateVccRequest();
 	~CreateVccRequest();
 	std::string getBgpCidr() const;
@@ -36,29 +40,50 @@ public:
 	void setCenId(const std::string &cenId);
 	std::string getDescription() const;
 	void setDescription(const std::string &description);
+	std::string getCenOwnerId() const;
+	void setCenOwnerId(const std::string &cenOwnerId);
 	bool getAccessCouldService() const;
 	void setAccessCouldService(bool accessCouldService);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getVccName() const;
+	void setVccName(const std::string &vccName);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
 	std::string getVccId() const;
 	void setVccId(const std::string &vccId);
+	std::string getConnectionType() const;
+	void setConnectionType(const std::string &connectionType);
+	int getBandwidth() const;
+	void setBandwidth(int bandwidth);
 	std::string getVSwitchId() const;
 	void setVSwitchId(const std::string &vSwitchId);
 	std::string getVpdId() const;
 	void setVpdId(const std::string &vpdId);
 	std::string getVpcId() const;
 	void setVpcId(const std::string &vpcId);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
 
 private:
 	std::string bgpCidr_;
 	std::string cenId_;
 	std::string description_;
+	std::string cenOwnerId_;
 	bool accessCouldService_;
+	std::string resourceGroupId_;
+	std::string vccName_;
 	std::string regionId_;
+	std::vector<Tag> tag_;
 	std::string vccId_;
+	std::string connectionType_;
+	int bandwidth_;
 	std::string vSwitchId_;
 	std::string vpdId_;
 	std::string vpcId_;
+	std::string zoneId_;
 };
 } // namespace Model
 } // namespace Eflo

eflo/include/alibabacloud/eflo/model/CreateVccRouteEntryRequest.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_EFLO_MODEL_CREATEVCCROUTEENTRYREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEVCCROUTEENTRYREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT CreateVccRouteEntryRequest : public RpcServiceRequest {
+public:
+	CreateVccRouteEntryRequest();
+	~CreateVccRouteEntryRequest();
+	std::string getDestinationCidrBlock() const;
+	void setDestinationCidrBlock(const std::string &destinationCidrBlock);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getVccId() const;
+	void setVccId(const std::string &vccId);
+
+private:
+	std::string destinationCidrBlock_;
+	std::string regionId_;
+	std::string vccId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEVCCROUTEENTRYREQUEST_H_

eflo/include/alibabacloud/eflo/model/CreateVccRouteEntryResult.h

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

eflo/include/alibabacloud/eflo/model/CreateVpdGrantRuleRequest.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_EFLO_MODEL_CREATEVPDGRANTRULEREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEVPDGRANTRULEREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT CreateVpdGrantRuleRequest : public RpcServiceRequest {
+public:
+	CreateVpdGrantRuleRequest();
+	~CreateVpdGrantRuleRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getGrantTenantId() const;
+	void setGrantTenantId(const std::string &grantTenantId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string erId_;
+	std::string grantTenantId_;
+	std::string instanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEVPDGRANTRULEREQUEST_H_

eflo/include/alibabacloud/eflo/model/CreateVpdGrantRuleResult.h

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

eflo/include/alibabacloud/eflo/model/CreateVpdRequest.h

@@ -30,27 +30,37 @@ class ALIBABACLOUD_EFLO_EXPORT CreateVpdRequest : public RpcServiceRequest {
 public:
 	struct Subnets {
 		std::string regionId;
-		std::string name;
 		std::string zoneId;
 		std::string cidr;
+		std::string subnetName;
 		std::string type;
 	};
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
 	CreateVpdRequest();
 	~CreateVpdRequest();
+	std::string getVpdName() const;
+	void setVpdName(const std::string &vpdName);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
-	std::string getName() const;
-	void setName(const std::string &name);
 	std::string getCidr() const;
 	void setCidr(const std::string &cidr);
 	std::vector<Subnets> getSubnets() const;
 	void setSubnets(const std::vector<Subnets> &subnets);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
 
 private:
+	std::string vpdName_;
+	std::string resourceGroupId_;
 	std::string regionId_;
-	std::string name_;
 	std::string cidr_;
 	std::vector<Subnets> subnets_;
+	std::vector<Tag> tag_;
 };
 } // namespace Model
 } // namespace Eflo

eflo/include/alibabacloud/eflo/model/DeleteElasticNetworkInterfaceRequest.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_EFLO_MODEL_DELETEELASTICNETWORKINTERFACEREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_DELETEELASTICNETWORKINTERFACEREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT DeleteElasticNetworkInterfaceRequest : public RpcServiceRequest {
+public:
+	DeleteElasticNetworkInterfaceRequest();
+	~DeleteElasticNetworkInterfaceRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getElasticNetworkInterfaceId() const;
+	void setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId);
+
+private:
+	std::string regionId_;
+	std::string elasticNetworkInterfaceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_DELETEELASTICNETWORKINTERFACEREQUEST_H_

eflo/include/alibabacloud/eflo/model/DeleteElasticNetworkInterfaceResult.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_EFLO_MODEL_DELETEELASTICNETWORKINTERFACERESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_DELETEELASTICNETWORKINTERFACERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eflo/EfloExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eflo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EFLO_EXPORT DeleteElasticNetworkInterfaceResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string elasticNetworkInterfaceId;
+					std::string nodeId;
+				};
+
+
+				DeleteElasticNetworkInterfaceResult();
+				explicit DeleteElasticNetworkInterfaceResult(const std::string &payload);
+				~DeleteElasticNetworkInterfaceResult();
+				std::string getMessage()const;
+				Content getContent()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Content content_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EFLO_MODEL_DELETEELASTICNETWORKINTERFACERESULT_H_

eflo/include/alibabacloud/eflo/model/DeleteErAttachmentRequest.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_EFLO_MODEL_DELETEERATTACHMENTREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_DELETEERATTACHMENTREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT DeleteErAttachmentRequest : public RpcServiceRequest {
+public:
+	DeleteErAttachmentRequest();
+	~DeleteErAttachmentRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getErAttachmentId() const;
+	void setErAttachmentId(const std::string &erAttachmentId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string erId_;
+	std::string erAttachmentId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_DELETEERATTACHMENTREQUEST_H_

eflo/include/alibabacloud/eflo/model/DeleteErAttachmentResult.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_EFLO_MODEL_DELETEERATTACHMENTRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_DELETEERATTACHMENTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eflo/EfloExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eflo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EFLO_EXPORT DeleteErAttachmentResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteErAttachmentResult();
+				explicit DeleteErAttachmentResult(const std::string &payload);
+				~DeleteErAttachmentResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EFLO_MODEL_DELETEERATTACHMENTRESULT_H_

eflo/include/alibabacloud/eflo/model/DeleteErRequest.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_EFLO_MODEL_DELETEERREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_DELETEERREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT DeleteErRequest : public RpcServiceRequest {
+public:
+	DeleteErRequest();
+	~DeleteErRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string erId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_DELETEERREQUEST_H_