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.1635
+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/CreateDBClusterRequest.h

@@ -28,6 +28,10 @@ namespace Adb {
 namespace Model {
 class ALIBABACLOUD_ADB_EXPORT CreateDBClusterRequest : public RpcServiceRequest {
 public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
 	CreateDBClusterRequest();
 	~CreateDBClusterRequest();
 	long getResourceOwnerId() const;
@@ -40,6 +44,8 @@ public:
 	void setMode(const std::string &mode);
 	std::string getResourceGroupId() const;
 	void setResourceGroupId(const std::string &resourceGroupId);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
 	std::string getPeriod() const;
 	void setPeriod(const std::string &period);
 	std::string getBackupSetID() const;
@@ -99,6 +105,7 @@ private:
 	std::string storageType_;
 	std::string mode_;
 	std::string resourceGroupId_;
+	std::vector<Tag> tag_;
 	std::string period_;
 	std::string backupSetID_;
 	long ownerId_;

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/DescribeEIURangeRequest.h

@@ -34,6 +34,8 @@ public:
 	void setResourceOwnerId(long resourceOwnerId);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	std::string getResourceOwnerAccount() const;
@@ -56,6 +58,7 @@ public:
 private:
 	long resourceOwnerId_;
 	std::string accessKeyId_;
+	std::string resourceGroupId_;
 	std::string regionId_;
 	std::string resourceOwnerAccount_;
 	std::string dBClusterId_;

adb/include/alibabacloud/adb/model/DescribeLoadTasksRecordsRequest.h

@@ -40,6 +40,8 @@ public:
 	void setPageNumber(int pageNumber);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
 	int getPageSize() const;
 	void setPageSize(int pageSize);
 	std::string getState() const;
@@ -65,6 +67,7 @@ private:
 	std::string startTime_;
 	int pageNumber_;
 	std::string accessKeyId_;
+	std::string regionId_;
 	int pageSize_;
 	std::string state_;
 	std::string order_;

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/DescribeTaskInfoRequest.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);
 	int getTaskId() const;
 	void setTaskId(int taskId);
 	std::string getResourceOwnerAccount() const;
@@ -48,6 +50,7 @@ public:
 private:
 	long resourceOwnerId_;
 	std::string accessKeyId_;
+	std::string regionId_;
 	int taskId_;
 	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/include/alibabacloud/adb/model/ModifyLogBackupPolicyRequest.h

@@ -34,6 +34,8 @@ public:
 	void setResourceOwnerId(long resourceOwnerId);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getEnableBackupLog() const;
 	void setEnableBackupLog(const std::string &enableBackupLog);
 	std::string getResourceOwnerAccount() const;
@@ -50,6 +52,7 @@ public:
 private:
 	long resourceOwnerId_;
 	std::string accessKeyId_;
+	std::string resourceGroupId_;
 	std::string enableBackupLog_;
 	std::string resourceOwnerAccount_;
 	std::string dBClusterId_;

adb/include/alibabacloud/adb/model/ModifyMaintenanceActionRequest.h

@@ -34,6 +34,8 @@ public:
 	void setResourceOwnerId(long resourceOwnerId);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	std::string getSwitchTime() const;
@@ -50,6 +52,7 @@ public:
 private:
 	long resourceOwnerId_;
 	std::string accessKeyId_;
+	std::string resourceGroupId_;
 	std::string regionId_;
 	std::string switchTime_;
 	std::string resourceOwnerAccount_;

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/CreateDBClusterRequest.cc

@@ -70,6 +70,20 @@ void CreateDBClusterRequest::setResourceGroupId(const std::string &resourceGroup
   setParameter(std::string("ResourceGroupId"), resourceGroupId);
 }
 
+std::vector<CreateDBClusterRequest::Tag> CreateDBClusterRequest::getTag() const {
+  return tag_;
+}
+
+void CreateDBClusterRequest::setTag(const std::vector<CreateDBClusterRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
 std::string CreateDBClusterRequest::getPeriod() const {
   return period_;
 }

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/DescribeEIURangeRequest.cc

@@ -43,6 +43,15 @@ void DescribeEIURangeRequest::setAccessKeyId(const std::string &accessKeyId) {
   setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
+std::string DescribeEIURangeRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void DescribeEIURangeRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
 std::string DescribeEIURangeRequest::getRegionId() const {
   return regionId_;
 }

adb/src/model/DescribeLoadTasksRecordsRequest.cc

@@ -70,6 +70,15 @@ void DescribeLoadTasksRecordsRequest::setAccessKeyId(const std::string &accessKe
   setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
+std::string DescribeLoadTasksRecordsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeLoadTasksRecordsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
 int DescribeLoadTasksRecordsRequest::getPageSize() const {
   return pageSize_;
 }

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/DescribeTaskInfoRequest.cc

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

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());
+
+}
+

adb/src/model/ModifyLogBackupPolicyRequest.cc

@@ -43,6 +43,15 @@ void ModifyLogBackupPolicyRequest::setAccessKeyId(const std::string &accessKeyId
   setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
+std::string ModifyLogBackupPolicyRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void ModifyLogBackupPolicyRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
 std::string ModifyLogBackupPolicyRequest::getEnableBackupLog() const {
   return enableBackupLog_;
 }

adb/src/model/ModifyMaintenanceActionRequest.cc

@@ -43,6 +43,15 @@ void ModifyMaintenanceActionRequest::setAccessKeyId(const std::string &accessKey
   setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
+std::string ModifyMaintenanceActionRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void ModifyMaintenanceActionRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
 std::string ModifyMaintenanceActionRequest::getRegionId() const {
   return regionId_;
 }

adcp/CMakeLists.txt

@@ -0,0 +1,174 @@
+#
+# 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.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(adcp_public_header 
+	include/alibabacloud/adcp/AdcpClient.h
+	include/alibabacloud/adcp/AdcpExport.h )
+
+set(adcp_public_header_model 
+	include/alibabacloud/adcp/model/AttachClusterToHubRequest.h
+	include/alibabacloud/adcp/model/AttachClusterToHubResult.h
+	include/alibabacloud/adcp/model/CreateHubClusterRequest.h
+	include/alibabacloud/adcp/model/CreateHubClusterResult.h
+	include/alibabacloud/adcp/model/DeleteHubClusterRequest.h
+	include/alibabacloud/adcp/model/DeleteHubClusterResult.h
+	include/alibabacloud/adcp/model/DeletePolicyInstanceRequest.h
+	include/alibabacloud/adcp/model/DeletePolicyInstanceResult.h
+	include/alibabacloud/adcp/model/DeleteUserPermissionRequest.h
+	include/alibabacloud/adcp/model/DeleteUserPermissionResult.h
+	include/alibabacloud/adcp/model/DeployPolicyInstanceRequest.h
+	include/alibabacloud/adcp/model/DeployPolicyInstanceResult.h
+	include/alibabacloud/adcp/model/DescribeHubClusterDetailsRequest.h
+	include/alibabacloud/adcp/model/DescribeHubClusterDetailsResult.h
+	include/alibabacloud/adcp/model/DescribeHubClusterKubeconfigRequest.h
+	include/alibabacloud/adcp/model/DescribeHubClusterKubeconfigResult.h
+	include/alibabacloud/adcp/model/DescribeHubClusterLogsRequest.h
+	include/alibabacloud/adcp/model/DescribeHubClusterLogsResult.h
+	include/alibabacloud/adcp/model/DescribeHubClustersRequest.h
+	include/alibabacloud/adcp/model/DescribeHubClustersResult.h
+	include/alibabacloud/adcp/model/DescribeManagedClustersRequest.h
+	include/alibabacloud/adcp/model/DescribeManagedClustersResult.h
+	include/alibabacloud/adcp/model/DescribePoliciesRequest.h
+	include/alibabacloud/adcp/model/DescribePoliciesResult.h
+	include/alibabacloud/adcp/model/DescribePolicyDetailsRequest.h
+	include/alibabacloud/adcp/model/DescribePolicyDetailsResult.h
+	include/alibabacloud/adcp/model/DescribePolicyGovernanceInClusterRequest.h
+	include/alibabacloud/adcp/model/DescribePolicyGovernanceInClusterResult.h
+	include/alibabacloud/adcp/model/DescribePolicyInstancesRequest.h
+	include/alibabacloud/adcp/model/DescribePolicyInstancesResult.h
+	include/alibabacloud/adcp/model/DescribePolicyInstancesStatusRequest.h
+	include/alibabacloud/adcp/model/DescribePolicyInstancesStatusResult.h
+	include/alibabacloud/adcp/model/DescribeRegionsRequest.h
+	include/alibabacloud/adcp/model/DescribeRegionsResult.h
+	include/alibabacloud/adcp/model/DescribeUserPermissionsRequest.h
+	include/alibabacloud/adcp/model/DescribeUserPermissionsResult.h
+	include/alibabacloud/adcp/model/DetachClusterFromHubRequest.h
+	include/alibabacloud/adcp/model/DetachClusterFromHubResult.h
+	include/alibabacloud/adcp/model/GrantUserPermissionRequest.h
+	include/alibabacloud/adcp/model/GrantUserPermissionResult.h
+	include/alibabacloud/adcp/model/GrantUserPermissionsRequest.h
+	include/alibabacloud/adcp/model/GrantUserPermissionsResult.h
+	include/alibabacloud/adcp/model/UpdateHubClusterFeatureRequest.h
+	include/alibabacloud/adcp/model/UpdateHubClusterFeatureResult.h
+	include/alibabacloud/adcp/model/UpdateUserPermissionRequest.h
+	include/alibabacloud/adcp/model/UpdateUserPermissionResult.h )
+
+set(adcp_src 
+	src/AdcpClient.cc
+	src/model/AttachClusterToHubRequest.cc
+	src/model/AttachClusterToHubResult.cc
+	src/model/CreateHubClusterRequest.cc
+	src/model/CreateHubClusterResult.cc
+	src/model/DeleteHubClusterRequest.cc
+	src/model/DeleteHubClusterResult.cc
+	src/model/DeletePolicyInstanceRequest.cc
+	src/model/DeletePolicyInstanceResult.cc
+	src/model/DeleteUserPermissionRequest.cc
+	src/model/DeleteUserPermissionResult.cc
+	src/model/DeployPolicyInstanceRequest.cc
+	src/model/DeployPolicyInstanceResult.cc
+	src/model/DescribeHubClusterDetailsRequest.cc
+	src/model/DescribeHubClusterDetailsResult.cc
+	src/model/DescribeHubClusterKubeconfigRequest.cc
+	src/model/DescribeHubClusterKubeconfigResult.cc
+	src/model/DescribeHubClusterLogsRequest.cc
+	src/model/DescribeHubClusterLogsResult.cc
+	src/model/DescribeHubClustersRequest.cc
+	src/model/DescribeHubClustersResult.cc
+	src/model/DescribeManagedClustersRequest.cc
+	src/model/DescribeManagedClustersResult.cc
+	src/model/DescribePoliciesRequest.cc
+	src/model/DescribePoliciesResult.cc
+	src/model/DescribePolicyDetailsRequest.cc
+	src/model/DescribePolicyDetailsResult.cc
+	src/model/DescribePolicyGovernanceInClusterRequest.cc
+	src/model/DescribePolicyGovernanceInClusterResult.cc
+	src/model/DescribePolicyInstancesRequest.cc
+	src/model/DescribePolicyInstancesResult.cc
+	src/model/DescribePolicyInstancesStatusRequest.cc
+	src/model/DescribePolicyInstancesStatusResult.cc
+	src/model/DescribeRegionsRequest.cc
+	src/model/DescribeRegionsResult.cc
+	src/model/DescribeUserPermissionsRequest.cc
+	src/model/DescribeUserPermissionsResult.cc
+	src/model/DetachClusterFromHubRequest.cc
+	src/model/DetachClusterFromHubResult.cc
+	src/model/GrantUserPermissionRequest.cc
+	src/model/GrantUserPermissionResult.cc
+	src/model/GrantUserPermissionsRequest.cc
+	src/model/GrantUserPermissionsResult.cc
+	src/model/UpdateHubClusterFeatureRequest.cc
+	src/model/UpdateHubClusterFeatureResult.cc
+	src/model/UpdateUserPermissionRequest.cc
+	src/model/UpdateUserPermissionResult.cc )
+
+add_library(adcp ${LIB_TYPE}
+	${adcp_public_header}
+	${adcp_public_header_model}
+	${adcp_src})
+
+set_target_properties(adcp
+	PROPERTIES
+	LINKER_LANGUAGE CXX
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+	OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}adcp
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(adcp
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_ADCP_LIBRARY)
+endif()
+
+target_include_directories(adcp
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(adcp
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(adcp
+		jsoncpp)
+	target_include_directories(adcp
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(adcp
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(adcp
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(adcp
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(adcp
+		jsoncpp)
+endif()
+
+install(FILES ${adcp_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/adcp)
+install(FILES ${adcp_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/adcp/model)
+install(TARGETS adcp
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

adcp/include/alibabacloud/adcp/AdcpClient.h

@@ -0,0 +1,230 @@
+/*
+ * 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_ADCP_ADCPCLIENT_H_
+#define ALIBABACLOUD_ADCP_ADCPCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "AdcpExport.h"
+#include "model/AttachClusterToHubRequest.h"
+#include "model/AttachClusterToHubResult.h"
+#include "model/CreateHubClusterRequest.h"
+#include "model/CreateHubClusterResult.h"
+#include "model/DeleteHubClusterRequest.h"
+#include "model/DeleteHubClusterResult.h"
+#include "model/DeletePolicyInstanceRequest.h"
+#include "model/DeletePolicyInstanceResult.h"
+#include "model/DeleteUserPermissionRequest.h"
+#include "model/DeleteUserPermissionResult.h"
+#include "model/DeployPolicyInstanceRequest.h"
+#include "model/DeployPolicyInstanceResult.h"
+#include "model/DescribeHubClusterDetailsRequest.h"
+#include "model/DescribeHubClusterDetailsResult.h"
+#include "model/DescribeHubClusterKubeconfigRequest.h"
+#include "model/DescribeHubClusterKubeconfigResult.h"
+#include "model/DescribeHubClusterLogsRequest.h"
+#include "model/DescribeHubClusterLogsResult.h"
+#include "model/DescribeHubClustersRequest.h"
+#include "model/DescribeHubClustersResult.h"
+#include "model/DescribeManagedClustersRequest.h"
+#include "model/DescribeManagedClustersResult.h"
+#include "model/DescribePoliciesRequest.h"
+#include "model/DescribePoliciesResult.h"
+#include "model/DescribePolicyDetailsRequest.h"
+#include "model/DescribePolicyDetailsResult.h"
+#include "model/DescribePolicyGovernanceInClusterRequest.h"
+#include "model/DescribePolicyGovernanceInClusterResult.h"
+#include "model/DescribePolicyInstancesRequest.h"
+#include "model/DescribePolicyInstancesResult.h"
+#include "model/DescribePolicyInstancesStatusRequest.h"
+#include "model/DescribePolicyInstancesStatusResult.h"
+#include "model/DescribeRegionsRequest.h"
+#include "model/DescribeRegionsResult.h"
+#include "model/DescribeUserPermissionsRequest.h"
+#include "model/DescribeUserPermissionsResult.h"
+#include "model/DetachClusterFromHubRequest.h"
+#include "model/DetachClusterFromHubResult.h"
+#include "model/GrantUserPermissionRequest.h"
+#include "model/GrantUserPermissionResult.h"
+#include "model/GrantUserPermissionsRequest.h"
+#include "model/GrantUserPermissionsResult.h"
+#include "model/UpdateHubClusterFeatureRequest.h"
+#include "model/UpdateHubClusterFeatureResult.h"
+#include "model/UpdateUserPermissionRequest.h"
+#include "model/UpdateUserPermissionResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Adcp
+	{
+		class ALIBABACLOUD_ADCP_EXPORT AdcpClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::AttachClusterToHubResult> AttachClusterToHubOutcome;
+			typedef std::future<AttachClusterToHubOutcome> AttachClusterToHubOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::AttachClusterToHubRequest&, const AttachClusterToHubOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachClusterToHubAsyncHandler;
+			typedef Outcome<Error, Model::CreateHubClusterResult> CreateHubClusterOutcome;
+			typedef std::future<CreateHubClusterOutcome> CreateHubClusterOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::CreateHubClusterRequest&, const CreateHubClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateHubClusterAsyncHandler;
+			typedef Outcome<Error, Model::DeleteHubClusterResult> DeleteHubClusterOutcome;
+			typedef std::future<DeleteHubClusterOutcome> DeleteHubClusterOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DeleteHubClusterRequest&, const DeleteHubClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteHubClusterAsyncHandler;
+			typedef Outcome<Error, Model::DeletePolicyInstanceResult> DeletePolicyInstanceOutcome;
+			typedef std::future<DeletePolicyInstanceOutcome> DeletePolicyInstanceOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DeletePolicyInstanceRequest&, const DeletePolicyInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeletePolicyInstanceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteUserPermissionResult> DeleteUserPermissionOutcome;
+			typedef std::future<DeleteUserPermissionOutcome> DeleteUserPermissionOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DeleteUserPermissionRequest&, const DeleteUserPermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteUserPermissionAsyncHandler;
+			typedef Outcome<Error, Model::DeployPolicyInstanceResult> DeployPolicyInstanceOutcome;
+			typedef std::future<DeployPolicyInstanceOutcome> DeployPolicyInstanceOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DeployPolicyInstanceRequest&, const DeployPolicyInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeployPolicyInstanceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeHubClusterDetailsResult> DescribeHubClusterDetailsOutcome;
+			typedef std::future<DescribeHubClusterDetailsOutcome> DescribeHubClusterDetailsOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DescribeHubClusterDetailsRequest&, const DescribeHubClusterDetailsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeHubClusterDetailsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeHubClusterKubeconfigResult> DescribeHubClusterKubeconfigOutcome;
+			typedef std::future<DescribeHubClusterKubeconfigOutcome> DescribeHubClusterKubeconfigOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DescribeHubClusterKubeconfigRequest&, const DescribeHubClusterKubeconfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeHubClusterKubeconfigAsyncHandler;
+			typedef Outcome<Error, Model::DescribeHubClusterLogsResult> DescribeHubClusterLogsOutcome;
+			typedef std::future<DescribeHubClusterLogsOutcome> DescribeHubClusterLogsOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DescribeHubClusterLogsRequest&, const DescribeHubClusterLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeHubClusterLogsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeHubClustersResult> DescribeHubClustersOutcome;
+			typedef std::future<DescribeHubClustersOutcome> DescribeHubClustersOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DescribeHubClustersRequest&, const DescribeHubClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeHubClustersAsyncHandler;
+			typedef Outcome<Error, Model::DescribeManagedClustersResult> DescribeManagedClustersOutcome;
+			typedef std::future<DescribeManagedClustersOutcome> DescribeManagedClustersOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DescribeManagedClustersRequest&, const DescribeManagedClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeManagedClustersAsyncHandler;
+			typedef Outcome<Error, Model::DescribePoliciesResult> DescribePoliciesOutcome;
+			typedef std::future<DescribePoliciesOutcome> DescribePoliciesOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DescribePoliciesRequest&, const DescribePoliciesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePoliciesAsyncHandler;
+			typedef Outcome<Error, Model::DescribePolicyDetailsResult> DescribePolicyDetailsOutcome;
+			typedef std::future<DescribePolicyDetailsOutcome> DescribePolicyDetailsOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DescribePolicyDetailsRequest&, const DescribePolicyDetailsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePolicyDetailsAsyncHandler;
+			typedef Outcome<Error, Model::DescribePolicyGovernanceInClusterResult> DescribePolicyGovernanceInClusterOutcome;
+			typedef std::future<DescribePolicyGovernanceInClusterOutcome> DescribePolicyGovernanceInClusterOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DescribePolicyGovernanceInClusterRequest&, const DescribePolicyGovernanceInClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePolicyGovernanceInClusterAsyncHandler;
+			typedef Outcome<Error, Model::DescribePolicyInstancesResult> DescribePolicyInstancesOutcome;
+			typedef std::future<DescribePolicyInstancesOutcome> DescribePolicyInstancesOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DescribePolicyInstancesRequest&, const DescribePolicyInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePolicyInstancesAsyncHandler;
+			typedef Outcome<Error, Model::DescribePolicyInstancesStatusResult> DescribePolicyInstancesStatusOutcome;
+			typedef std::future<DescribePolicyInstancesStatusOutcome> DescribePolicyInstancesStatusOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DescribePolicyInstancesStatusRequest&, const DescribePolicyInstancesStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePolicyInstancesStatusAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
+			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeUserPermissionsResult> DescribeUserPermissionsOutcome;
+			typedef std::future<DescribeUserPermissionsOutcome> DescribeUserPermissionsOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DescribeUserPermissionsRequest&, const DescribeUserPermissionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUserPermissionsAsyncHandler;
+			typedef Outcome<Error, Model::DetachClusterFromHubResult> DetachClusterFromHubOutcome;
+			typedef std::future<DetachClusterFromHubOutcome> DetachClusterFromHubOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::DetachClusterFromHubRequest&, const DetachClusterFromHubOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachClusterFromHubAsyncHandler;
+			typedef Outcome<Error, Model::GrantUserPermissionResult> GrantUserPermissionOutcome;
+			typedef std::future<GrantUserPermissionOutcome> GrantUserPermissionOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::GrantUserPermissionRequest&, const GrantUserPermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GrantUserPermissionAsyncHandler;
+			typedef Outcome<Error, Model::GrantUserPermissionsResult> GrantUserPermissionsOutcome;
+			typedef std::future<GrantUserPermissionsOutcome> GrantUserPermissionsOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::GrantUserPermissionsRequest&, const GrantUserPermissionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GrantUserPermissionsAsyncHandler;
+			typedef Outcome<Error, Model::UpdateHubClusterFeatureResult> UpdateHubClusterFeatureOutcome;
+			typedef std::future<UpdateHubClusterFeatureOutcome> UpdateHubClusterFeatureOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::UpdateHubClusterFeatureRequest&, const UpdateHubClusterFeatureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateHubClusterFeatureAsyncHandler;
+			typedef Outcome<Error, Model::UpdateUserPermissionResult> UpdateUserPermissionOutcome;
+			typedef std::future<UpdateUserPermissionOutcome> UpdateUserPermissionOutcomeCallable;
+			typedef std::function<void(const AdcpClient*, const Model::UpdateUserPermissionRequest&, const UpdateUserPermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateUserPermissionAsyncHandler;
+
+			AdcpClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			AdcpClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			AdcpClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~AdcpClient();
+			AttachClusterToHubOutcome attachClusterToHub(const Model::AttachClusterToHubRequest &request)const;
+			void attachClusterToHubAsync(const Model::AttachClusterToHubRequest& request, const AttachClusterToHubAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AttachClusterToHubOutcomeCallable attachClusterToHubCallable(const Model::AttachClusterToHubRequest& request) const;
+			CreateHubClusterOutcome createHubCluster(const Model::CreateHubClusterRequest &request)const;
+			void createHubClusterAsync(const Model::CreateHubClusterRequest& request, const CreateHubClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateHubClusterOutcomeCallable createHubClusterCallable(const Model::CreateHubClusterRequest& request) const;
+			DeleteHubClusterOutcome deleteHubCluster(const Model::DeleteHubClusterRequest &request)const;
+			void deleteHubClusterAsync(const Model::DeleteHubClusterRequest& request, const DeleteHubClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteHubClusterOutcomeCallable deleteHubClusterCallable(const Model::DeleteHubClusterRequest& request) const;
+			DeletePolicyInstanceOutcome deletePolicyInstance(const Model::DeletePolicyInstanceRequest &request)const;
+			void deletePolicyInstanceAsync(const Model::DeletePolicyInstanceRequest& request, const DeletePolicyInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeletePolicyInstanceOutcomeCallable deletePolicyInstanceCallable(const Model::DeletePolicyInstanceRequest& request) const;
+			DeleteUserPermissionOutcome deleteUserPermission(const Model::DeleteUserPermissionRequest &request)const;
+			void deleteUserPermissionAsync(const Model::DeleteUserPermissionRequest& request, const DeleteUserPermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteUserPermissionOutcomeCallable deleteUserPermissionCallable(const Model::DeleteUserPermissionRequest& request) const;
+			DeployPolicyInstanceOutcome deployPolicyInstance(const Model::DeployPolicyInstanceRequest &request)const;
+			void deployPolicyInstanceAsync(const Model::DeployPolicyInstanceRequest& request, const DeployPolicyInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeployPolicyInstanceOutcomeCallable deployPolicyInstanceCallable(const Model::DeployPolicyInstanceRequest& request) const;
+			DescribeHubClusterDetailsOutcome describeHubClusterDetails(const Model::DescribeHubClusterDetailsRequest &request)const;
+			void describeHubClusterDetailsAsync(const Model::DescribeHubClusterDetailsRequest& request, const DescribeHubClusterDetailsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeHubClusterDetailsOutcomeCallable describeHubClusterDetailsCallable(const Model::DescribeHubClusterDetailsRequest& request) const;
+			DescribeHubClusterKubeconfigOutcome describeHubClusterKubeconfig(const Model::DescribeHubClusterKubeconfigRequest &request)const;
+			void describeHubClusterKubeconfigAsync(const Model::DescribeHubClusterKubeconfigRequest& request, const DescribeHubClusterKubeconfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeHubClusterKubeconfigOutcomeCallable describeHubClusterKubeconfigCallable(const Model::DescribeHubClusterKubeconfigRequest& request) const;
+			DescribeHubClusterLogsOutcome describeHubClusterLogs(const Model::DescribeHubClusterLogsRequest &request)const;
+			void describeHubClusterLogsAsync(const Model::DescribeHubClusterLogsRequest& request, const DescribeHubClusterLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeHubClusterLogsOutcomeCallable describeHubClusterLogsCallable(const Model::DescribeHubClusterLogsRequest& request) const;
+			DescribeHubClustersOutcome describeHubClusters(const Model::DescribeHubClustersRequest &request)const;
+			void describeHubClustersAsync(const Model::DescribeHubClustersRequest& request, const DescribeHubClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeHubClustersOutcomeCallable describeHubClustersCallable(const Model::DescribeHubClustersRequest& request) const;
+			DescribeManagedClustersOutcome describeManagedClusters(const Model::DescribeManagedClustersRequest &request)const;
+			void describeManagedClustersAsync(const Model::DescribeManagedClustersRequest& request, const DescribeManagedClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeManagedClustersOutcomeCallable describeManagedClustersCallable(const Model::DescribeManagedClustersRequest& request) const;
+			DescribePoliciesOutcome describePolicies(const Model::DescribePoliciesRequest &request)const;
+			void describePoliciesAsync(const Model::DescribePoliciesRequest& request, const DescribePoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePoliciesOutcomeCallable describePoliciesCallable(const Model::DescribePoliciesRequest& request) const;
+			DescribePolicyDetailsOutcome describePolicyDetails(const Model::DescribePolicyDetailsRequest &request)const;
+			void describePolicyDetailsAsync(const Model::DescribePolicyDetailsRequest& request, const DescribePolicyDetailsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePolicyDetailsOutcomeCallable describePolicyDetailsCallable(const Model::DescribePolicyDetailsRequest& request) const;
+			DescribePolicyGovernanceInClusterOutcome describePolicyGovernanceInCluster(const Model::DescribePolicyGovernanceInClusterRequest &request)const;
+			void describePolicyGovernanceInClusterAsync(const Model::DescribePolicyGovernanceInClusterRequest& request, const DescribePolicyGovernanceInClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePolicyGovernanceInClusterOutcomeCallable describePolicyGovernanceInClusterCallable(const Model::DescribePolicyGovernanceInClusterRequest& request) const;
+			DescribePolicyInstancesOutcome describePolicyInstances(const Model::DescribePolicyInstancesRequest &request)const;
+			void describePolicyInstancesAsync(const Model::DescribePolicyInstancesRequest& request, const DescribePolicyInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePolicyInstancesOutcomeCallable describePolicyInstancesCallable(const Model::DescribePolicyInstancesRequest& request) const;
+			DescribePolicyInstancesStatusOutcome describePolicyInstancesStatus(const Model::DescribePolicyInstancesStatusRequest &request)const;
+			void describePolicyInstancesStatusAsync(const Model::DescribePolicyInstancesStatusRequest& request, const DescribePolicyInstancesStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePolicyInstancesStatusOutcomeCallable describePolicyInstancesStatusCallable(const Model::DescribePolicyInstancesStatusRequest& request) const;
+			DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
+			void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
+			DescribeUserPermissionsOutcome describeUserPermissions(const Model::DescribeUserPermissionsRequest &request)const;
+			void describeUserPermissionsAsync(const Model::DescribeUserPermissionsRequest& request, const DescribeUserPermissionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeUserPermissionsOutcomeCallable describeUserPermissionsCallable(const Model::DescribeUserPermissionsRequest& request) const;
+			DetachClusterFromHubOutcome detachClusterFromHub(const Model::DetachClusterFromHubRequest &request)const;
+			void detachClusterFromHubAsync(const Model::DetachClusterFromHubRequest& request, const DetachClusterFromHubAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetachClusterFromHubOutcomeCallable detachClusterFromHubCallable(const Model::DetachClusterFromHubRequest& request) const;
+			GrantUserPermissionOutcome grantUserPermission(const Model::GrantUserPermissionRequest &request)const;
+			void grantUserPermissionAsync(const Model::GrantUserPermissionRequest& request, const GrantUserPermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GrantUserPermissionOutcomeCallable grantUserPermissionCallable(const Model::GrantUserPermissionRequest& request) const;
+			GrantUserPermissionsOutcome grantUserPermissions(const Model::GrantUserPermissionsRequest &request)const;
+			void grantUserPermissionsAsync(const Model::GrantUserPermissionsRequest& request, const GrantUserPermissionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GrantUserPermissionsOutcomeCallable grantUserPermissionsCallable(const Model::GrantUserPermissionsRequest& request) const;
+			UpdateHubClusterFeatureOutcome updateHubClusterFeature(const Model::UpdateHubClusterFeatureRequest &request)const;
+			void updateHubClusterFeatureAsync(const Model::UpdateHubClusterFeatureRequest& request, const UpdateHubClusterFeatureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateHubClusterFeatureOutcomeCallable updateHubClusterFeatureCallable(const Model::UpdateHubClusterFeatureRequest& request) const;
+			UpdateUserPermissionOutcome updateUserPermission(const Model::UpdateUserPermissionRequest &request)const;
+			void updateUserPermissionAsync(const Model::UpdateUserPermissionRequest& request, const UpdateUserPermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateUserPermissionOutcomeCallable updateUserPermissionCallable(const Model::UpdateUserPermissionRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_ADCP_ADCPCLIENT_H_

adcp/include/alibabacloud/adcp/AdcpExport.h

@@ -0,0 +1,32 @@
+/*
+ * 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_ADCP_ADCPEXPORT_H_
+#define ALIBABACLOUD_ADCP_ADCPEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_ADCP_LIBRARY)
+#		define ALIBABACLOUD_ADCP_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_ADCP_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_ADCP_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_ADCP_ADCPEXPORT_H_

adcp/include/alibabacloud/adcp/model/AttachClusterToHubRequest.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_ADCP_MODEL_ATTACHCLUSTERTOHUBREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_ATTACHCLUSTERTOHUBREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT AttachClusterToHubRequest : public RpcServiceRequest {
+public:
+	AttachClusterToHubRequest();
+	~AttachClusterToHubRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getClusterIds() const;
+	void setClusterIds(const std::string &clusterIds);
+	bool getAttachToMesh() const;
+	void setAttachToMesh(bool attachToMesh);
+
+private:
+	std::string clusterId_;
+	std::string clusterIds_;
+	bool attachToMesh_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_ATTACHCLUSTERTOHUBREQUEST_H_

adcp/include/alibabacloud/adcp/model/AttachClusterToHubResult.h

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

adcp/include/alibabacloud/adcp/model/CreateHubClusterRequest.h

@@ -0,0 +1,121 @@
+/*
+ * 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_ADCP_MODEL_CREATEHUBCLUSTERREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_CREATEHUBCLUSTERREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT CreateHubClusterRequest : public RpcServiceRequest {
+public:
+	struct WorkflowUnits {
+		std::string regionId;
+		std::string vpcId;
+		struct VSwitchesItem {
+			std::string vswitchId;
+			std::string zoneId;
+		};
+		VSwitchesItem vSwitchesItem;
+		std::vector<VSwitchesItem> vSwitches;
+	};
+	CreateHubClusterRequest();
+	~CreateHubClusterRequest();
+	std::string getAuditLogProject() const;
+	void setAuditLogProject(const std::string &auditLogProject);
+	std::string getLoadBalancerSpec() const;
+	void setLoadBalancerSpec(const std::string &loadBalancerSpec);
+	std::string getKubernetesVersion() const;
+	void setKubernetesVersion(const std::string &kubernetesVersion);
+	std::string getProfile() const;
+	void setProfile(const std::string &profile);
+	std::string getVSwitches() const;
+	void setVSwitches(const std::string &vSwitches);
+	std::string getControlPlaneLogProject() const;
+	void setControlPlaneLogProject(const std::string &controlPlaneLogProject);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+	std::string getClusterSpec() const;
+	void setClusterSpec(const std::string &clusterSpec);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getClusterDomain() const;
+	void setClusterDomain(const std::string &clusterDomain);
+	std::string getControlPlaneLogTTL() const;
+	void setControlPlaneLogTTL(const std::string &controlPlaneLogTTL);
+	std::vector<WorkflowUnits> getWorkflowUnits() const;
+	void setWorkflowUnits(const std::vector<WorkflowUnits> &workflowUnits);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getAuditLogStoreTTL() const;
+	void setAuditLogStoreTTL(const std::string &auditLogStoreTTL);
+	std::string getIPStack() const;
+	void setIPStack(const std::string &iPStack);
+	bool getControlPlaneLogEnabled() const;
+	void setControlPlaneLogEnabled(bool controlPlaneLogEnabled);
+	bool getArgoServerEnabled() const;
+	void setArgoServerEnabled(bool argoServerEnabled);
+	std::string getWorkflowScheduleMode() const;
+	void setWorkflowScheduleMode(const std::string &workflowScheduleMode);
+	bool getApiServerPublicEip() const;
+	void setApiServerPublicEip(bool apiServerPublicEip);
+	bool getAuditLogEnabled() const;
+	void setAuditLogEnabled(bool auditLogEnabled);
+	std::string getSecurityGroupIDs() const;
+	void setSecurityGroupIDs(const std::string &securityGroupIDs);
+	std::string getPriceLimit() const;
+	void setPriceLimit(const std::string &priceLimit);
+	bool getIsEnterpriseSecurityGroup() const;
+	void setIsEnterpriseSecurityGroup(bool isEnterpriseSecurityGroup);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+
+private:
+	std::string auditLogProject_;
+	std::string loadBalancerSpec_;
+	std::string kubernetesVersion_;
+	std::string profile_;
+	std::string vSwitches_;
+	std::string controlPlaneLogProject_;
+	std::string loadBalancerId_;
+	std::string clusterSpec_;
+	std::string name_;
+	std::string clusterDomain_;
+	std::string controlPlaneLogTTL_;
+	std::vector<WorkflowUnits> workflowUnits_;
+	std::string regionId_;
+	std::string auditLogStoreTTL_;
+	std::string iPStack_;
+	bool controlPlaneLogEnabled_;
+	bool argoServerEnabled_;
+	std::string workflowScheduleMode_;
+	bool apiServerPublicEip_;
+	bool auditLogEnabled_;
+	std::string securityGroupIDs_;
+	std::string priceLimit_;
+	bool isEnterpriseSecurityGroup_;
+	std::string vpcId_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_CREATEHUBCLUSTERREQUEST_H_

adcp/include/alibabacloud/adcp/model/CreateHubClusterResult.h

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

adcp/include/alibabacloud/adcp/model/DeleteHubClusterRequest.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_ADCP_MODEL_DELETEHUBCLUSTERREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DELETEHUBCLUSTERREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DeleteHubClusterRequest : public RpcServiceRequest {
+public:
+	DeleteHubClusterRequest();
+	~DeleteHubClusterRequest();
+	std::vector<std::string> getRetainResources() const;
+	void setRetainResources(const std::vector<std::string> &retainResources);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	bool getForce() const;
+	void setForce(bool force);
+
+private:
+	std::vector<std::string> retainResources_;
+	std::string clusterId_;
+	bool force_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEHUBCLUSTERREQUEST_H_

adcp/include/alibabacloud/adcp/model/DeleteHubClusterResult.h

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

adcp/include/alibabacloud/adcp/model/DeletePolicyInstanceRequest.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_ADCP_MODEL_DELETEPOLICYINSTANCEREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DELETEPOLICYINSTANCEREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DeletePolicyInstanceRequest : public RpcServiceRequest {
+public:
+	DeletePolicyInstanceRequest();
+	~DeletePolicyInstanceRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::vector<std::string> getClusterIds() const;
+	void setClusterIds(const std::vector<std::string> &clusterIds);
+	std::string getPolicyName() const;
+	void setPolicyName(const std::string &policyName);
+
+private:
+	std::string clusterId_;
+	std::vector<std::string> clusterIds_;
+	std::string policyName_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEPOLICYINSTANCEREQUEST_H_

adcp/include/alibabacloud/adcp/model/DeletePolicyInstanceResult.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_ADCP_MODEL_DELETEPOLICYINSTANCERESULT_H_
+#define ALIBABACLOUD_ADCP_MODEL_DELETEPOLICYINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/adcp/AdcpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Adcp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADCP_EXPORT DeletePolicyInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				DeletePolicyInstanceResult();
+				explicit DeletePolicyInstanceResult(const std::string &payload);
+				~DeletePolicyInstanceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEPOLICYINSTANCERESULT_H_

adcp/include/alibabacloud/adcp/model/DeleteUserPermissionRequest.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_ADCP_MODEL_DELETEUSERPERMISSIONREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DELETEUSERPERMISSIONREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DeleteUserPermissionRequest : public RpcServiceRequest {
+public:
+	DeleteUserPermissionRequest();
+	~DeleteUserPermissionRequest();
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+
+private:
+	std::string userId_;
+	std::string clusterId_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEUSERPERMISSIONREQUEST_H_

adcp/include/alibabacloud/adcp/model/DeleteUserPermissionResult.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_ADCP_MODEL_DELETEUSERPERMISSIONRESULT_H_
+#define ALIBABACLOUD_ADCP_MODEL_DELETEUSERPERMISSIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/adcp/AdcpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Adcp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADCP_EXPORT DeleteUserPermissionResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteUserPermissionResult();
+				explicit DeleteUserPermissionResult(const std::string &payload);
+				~DeleteUserPermissionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEUSERPERMISSIONRESULT_H_

adcp/include/alibabacloud/adcp/model/DeployPolicyInstanceRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADCP_MODEL_DEPLOYPOLICYINSTANCEREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DEPLOYPOLICYINSTANCEREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DeployPolicyInstanceRequest : public RpcServiceRequest {
+public:
+	DeployPolicyInstanceRequest();
+	~DeployPolicyInstanceRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getPolicyAction() const;
+	void setPolicyAction(const std::string &policyAction);
+	std::vector<std::string> getClusterIds() const;
+	void setClusterIds(const std::vector<std::string> &clusterIds);
+	std::string getPolicyName() const;
+	void setPolicyName(const std::string &policyName);
+	std::vector<std::string> getNamespaces() const;
+	void setNamespaces(const std::vector<std::string> &namespaces);
+
+private:
+	std::string clusterId_;
+	std::string policyAction_;
+	std::vector<std::string> clusterIds_;
+	std::string policyName_;
+	std::vector<std::string> namespaces_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DEPLOYPOLICYINSTANCEREQUEST_H_

adcp/include/alibabacloud/adcp/model/DeployPolicyInstanceResult.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_ADCP_MODEL_DEPLOYPOLICYINSTANCERESULT_H_
+#define ALIBABACLOUD_ADCP_MODEL_DEPLOYPOLICYINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/adcp/AdcpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Adcp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADCP_EXPORT DeployPolicyInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				DeployPolicyInstanceResult();
+				explicit DeployPolicyInstanceResult(const std::string &payload);
+				~DeployPolicyInstanceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADCP_MODEL_DEPLOYPOLICYINSTANCERESULT_H_

adcp/include/alibabacloud/adcp/model/DescribeHubClusterDetailsRequest.h

@@ -0,0 +1,42 @@
+/*
+ * 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_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterDetailsRequest : public RpcServiceRequest {
+public:
+	DescribeHubClusterDetailsRequest();
+	~DescribeHubClusterDetailsRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+
+private:
+	std::string clusterId_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSREQUEST_H_

adcp/include/alibabacloud/adcp/model/DescribeHubClusterDetailsResult.h

@@ -0,0 +1,130 @@
+/*
+ * 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_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSRESULT_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/adcp/AdcpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Adcp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterDetailsResult : public ServiceResult
+			{
+			public:
+				struct Cluster
+				{
+					struct Endpoints
+					{
+						std::string intranetApiServerEndpoint;
+						std::string publicApiServerEndpoint;
+					};
+					struct ClusterInfo
+					{
+						std::string version;
+						std::string clusterId;
+						std::string state;
+						std::string creationTime;
+						std::string updateTime;
+						std::string regionId;
+						std::string clusterSpec;
+						std::string errorMessage;
+						std::string profile;
+						std::string name;
+					};
+					struct Network
+					{
+						std::string iPStack;
+						std::string vpcId;
+						std::string clusterDomain;
+						std::vector<std::string> vSwitches;
+						std::vector<std::string> securityGroupIDs;
+					};
+					struct ApiServer
+					{
+						std::string apiServerEipId;
+						bool enabledPublic;
+						std::string loadBalancerId;
+					};
+					struct MeshConfig
+					{
+						std::string meshId;
+						bool enableMesh;
+					};
+					struct LogConfig
+					{
+						std::string logStoreTTL;
+						bool enableLog;
+						std::string logProject;
+					};
+					struct WorkflowConfig
+					{
+						struct WorkflowUnit
+						{
+							struct VSwitch
+							{
+								std::string zoneId;
+								std::string vswitchId;
+							};
+							std::string vpcId;
+							std::vector<WorkflowUnit::VSwitch> vSwitches1;
+							std::string regionId;
+						};
+						std::vector<WorkflowUnit> workflowUnits;
+						std::string priceLimit;
+						bool argoServerEnabled;
+						std::string workflowScheduleMode;
+					};
+					struct Condition
+					{
+						std::string status;
+						std::string type;
+						std::string message;
+						std::string reason;
+					};
+					Endpoints endpoints;
+					WorkflowConfig workflowConfig;
+					ClusterInfo clusterInfo;
+					ApiServer apiServer;
+					MeshConfig meshConfig;
+					Network network;
+					std::vector<Condition> conditions;
+					LogConfig logConfig;
+				};
+
+
+				DescribeHubClusterDetailsResult();
+				explicit DescribeHubClusterDetailsResult(const std::string &payload);
+				~DescribeHubClusterDetailsResult();
+				Cluster getCluster()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Cluster cluster_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSRESULT_H_

adcp/include/alibabacloud/adcp/model/DescribeHubClusterKubeconfigRequest.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_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterKubeconfigRequest : public RpcServiceRequest {
+public:
+	DescribeHubClusterKubeconfigRequest();
+	~DescribeHubClusterKubeconfigRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	bool getPrivateIpAddress() const;
+	void setPrivateIpAddress(bool privateIpAddress);
+
+private:
+	std::string clusterId_;
+	bool privateIpAddress_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGREQUEST_H_

adcp/include/alibabacloud/adcp/model/DescribeHubClusterKubeconfigResult.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_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGRESULT_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/adcp/AdcpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Adcp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterKubeconfigResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeHubClusterKubeconfigResult();
+				explicit DescribeHubClusterKubeconfigResult(const std::string &payload);
+				~DescribeHubClusterKubeconfigResult();
+				std::string getKubeconfig()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string kubeconfig_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGRESULT_H_

adcp/include/alibabacloud/adcp/model/DescribeHubClusterLogsRequest.h

@@ -0,0 +1,42 @@
+/*
+ * 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_ADCP_MODEL_DESCRIBEHUBCLUSTERLOGSREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERLOGSREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterLogsRequest : public RpcServiceRequest {
+public:
+	DescribeHubClusterLogsRequest();
+	~DescribeHubClusterLogsRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+
+private:
+	std::string clusterId_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERLOGSREQUEST_H_

adcp/include/alibabacloud/adcp/model/DescribeHubClusterLogsResult.h

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

adcp/include/alibabacloud/adcp/model/DescribeHubClustersRequest.h

@@ -0,0 +1,42 @@
+/*
+ * 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_ADCP_MODEL_DESCRIBEHUBCLUSTERSREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERSREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DescribeHubClustersRequest : public RpcServiceRequest {
+public:
+	DescribeHubClustersRequest();
+	~DescribeHubClustersRequest();
+	std::string getProfile() const;
+	void setProfile(const std::string &profile);
+
+private:
+	std::string profile_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERSREQUEST_H_

adcp/include/alibabacloud/adcp/model/DescribeHubClustersResult.h

@@ -0,0 +1,110 @@
+/*
+ * 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_ADCP_MODEL_DESCRIBEHUBCLUSTERSRESULT_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/adcp/AdcpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Adcp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADCP_EXPORT DescribeHubClustersResult : public ServiceResult
+			{
+			public:
+				struct Cluster
+				{
+					struct Endpoints
+					{
+						std::string intranetApiServerEndpoint;
+						std::string publicApiServerEndpoint;
+					};
+					struct ClusterInfo
+					{
+						std::string version;
+						std::string clusterId;
+						std::string state;
+						std::string creationTime;
+						std::string updateTime;
+						std::string regionId;
+						std::string clusterSpec;
+						std::string errorMessage;
+						std::string profile;
+						std::string name;
+					};
+					struct Network
+					{
+						std::string vpcId;
+						std::string clusterDomain;
+						std::vector<std::string> vSwitches;
+						std::vector<std::string> securityGroupIDs;
+					};
+					struct ApiServer
+					{
+						std::string apiServerEipId;
+						bool enabledPublic;
+						std::string loadBalancerId;
+					};
+					struct MeshConfig
+					{
+						std::string meshId;
+						bool enableMesh;
+					};
+					struct LogConfig
+					{
+						std::string logStoreTTL;
+						bool enableLog;
+						std::string logProject;
+					};
+					struct Condition
+					{
+						std::string status;
+						std::string type;
+						std::string message;
+						std::string reason;
+					};
+					Endpoints endpoints;
+					ClusterInfo clusterInfo;
+					ApiServer apiServer;
+					MeshConfig meshConfig;
+					Network network;
+					std::vector<Cluster::Condition> conditions;
+					LogConfig logConfig;
+				};
+
+
+				DescribeHubClustersResult();
+				explicit DescribeHubClustersResult(const std::string &payload);
+				~DescribeHubClustersResult();
+				std::vector<Cluster> getClusters()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Cluster> clusters_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERSRESULT_H_

adcp/include/alibabacloud/adcp/model/DescribeManagedClustersRequest.h

@@ -0,0 +1,42 @@
+/*
+ * 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_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DescribeManagedClustersRequest : public RpcServiceRequest {
+public:
+	DescribeManagedClustersRequest();
+	~DescribeManagedClustersRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+
+private:
+	std::string clusterId_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSREQUEST_H_

adcp/include/alibabacloud/adcp/model/DescribeManagedClustersResult.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_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSRESULT_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/adcp/AdcpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Adcp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADCP_EXPORT DescribeManagedClustersResult : public ServiceResult
+			{
+			public:
+				struct Cluster
+				{
+					struct Cluster1
+					{
+						std::string updated;
+						std::string resourceGroupId;
+						std::string clusterID;
+						std::string initVersion;
+						std::string currentVersion;
+						std::string vSwitchID;
+						std::string clusterType;
+						std::string clusterSpec;
+						std::string profile;
+						std::string name;
+						std::string created;
+						std::string vpcID;
+						std::string state;
+						std::string region;
+					};
+					struct Status
+					{
+						std::string message;
+						std::string state;
+					};
+					struct MeshStatus
+					{
+						bool inMesh;
+					};
+					Status status;
+					Cluster1 cluster1;
+					MeshStatus meshStatus;
+				};
+
+
+				DescribeManagedClustersResult();
+				explicit DescribeManagedClustersResult(const std::string &payload);
+				~DescribeManagedClustersResult();
+				std::vector<Cluster> getClusters()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Cluster> clusters_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSRESULT_H_

adcp/include/alibabacloud/adcp/model/DescribePoliciesRequest.h

@@ -0,0 +1,39 @@
+/*
+ * 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_ADCP_MODEL_DESCRIBEPOLICIESREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICIESREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DescribePoliciesRequest : public RpcServiceRequest {
+public:
+	DescribePoliciesRequest();
+	~DescribePoliciesRequest();
+
+private:
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICIESREQUEST_H_

adcp/include/alibabacloud/adcp/model/DescribePoliciesResult.h

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

adcp/include/alibabacloud/adcp/model/DescribePolicyDetailsRequest.h

@@ -0,0 +1,42 @@
+/*
+ * 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_ADCP_MODEL_DESCRIBEPOLICYDETAILSREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYDETAILSREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DescribePolicyDetailsRequest : public RpcServiceRequest {
+public:
+	DescribePolicyDetailsRequest();
+	~DescribePolicyDetailsRequest();
+	std::string getPolicyName() const;
+	void setPolicyName(const std::string &policyName);
+
+private:
+	std::string policyName_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYDETAILSREQUEST_H_

adcp/include/alibabacloud/adcp/model/DescribePolicyDetailsResult.h

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

adcp/include/alibabacloud/adcp/model/DescribePolicyGovernanceInClusterRequest.h

@@ -0,0 +1,42 @@
+/*
+ * 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_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DescribePolicyGovernanceInClusterRequest : public RpcServiceRequest {
+public:
+	DescribePolicyGovernanceInClusterRequest();
+	~DescribePolicyGovernanceInClusterRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+
+private:
+	std::string clusterId_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERREQUEST_H_

adcp/include/alibabacloud/adcp/model/DescribePolicyGovernanceInClusterResult.h

@@ -0,0 +1,125 @@
+/*
+ * 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_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERRESULT_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/adcp/AdcpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Adcp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADCP_EXPORT DescribePolicyGovernanceInClusterResult : public ServiceResult
+			{
+			public:
+				struct PolicyGovernance
+				{
+					struct Cluster
+					{
+						std::string clusterId;
+						std::string state;
+						std::string regionId;
+						std::string clusterType;
+						std::string clusterSpec;
+						std::string profile;
+						std::string name;
+					};
+					struct PolicyGovernance1
+					{
+						struct AdmitLog
+						{
+							std::string progress;
+							std::string logStore;
+							std::string count;
+							std::vector<std::string> logs;
+							std::string logProject;
+						};
+						struct Violation
+						{
+							struct TotalViolations
+							{
+								struct DenySeverity
+								{
+									long violations;
+									std::string severity;
+								};
+								struct WarnSeverity
+								{
+									std::string violations;
+									std::string severity;
+								};
+								std::vector<DenySeverity> deny;
+								std::vector<WarnSeverity> warn;
+							};
+							struct Violations
+							{
+								struct DenyViolations
+								{
+									std::string policyDescription;
+									long violations;
+									std::string policyName;
+									std::string severity;
+								};
+								struct WarnViolations
+								{
+									std::string policyDescription;
+									long violations;
+									std::string policyName;
+									std::string severity;
+								};
+								std::vector<WarnViolations> warn3;
+								std::vector<DenyViolations> deny2;
+							};
+							Violations violations;
+							TotalViolations totalViolations;
+						};
+						struct State
+						{
+							long totalCount;
+							long enabledCount;
+							std::string severity;
+						};
+						Violation violation;
+						AdmitLog admitLog;
+						std::vector<State> onState;
+					};
+					PolicyGovernance1 policyGovernance1;
+					Cluster cluster;
+				};
+
+
+				DescribePolicyGovernanceInClusterResult();
+				explicit DescribePolicyGovernanceInClusterResult(const std::string &payload);
+				~DescribePolicyGovernanceInClusterResult();
+				std::vector<PolicyGovernance> getPolicyGovernances()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<PolicyGovernance> policyGovernances_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERRESULT_H_

adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesRequest.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_ADCP_MODEL_DESCRIBEPOLICYINSTANCESREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DescribePolicyInstancesRequest : public RpcServiceRequest {
+public:
+	DescribePolicyInstancesRequest();
+	~DescribePolicyInstancesRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getPolicyName() const;
+	void setPolicyName(const std::string &policyName);
+
+private:
+	std::string clusterId_;
+	std::string policyName_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESREQUEST_H_

adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesResult.h

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

adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesStatusRequest.h

@@ -0,0 +1,42 @@
+/*
+ * 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_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DescribePolicyInstancesStatusRequest : public RpcServiceRequest {
+public:
+	DescribePolicyInstancesStatusRequest();
+	~DescribePolicyInstancesStatusRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+
+private:
+	std::string clusterId_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSREQUEST_H_

adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesStatusResult.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_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSRESULT_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/adcp/AdcpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Adcp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADCP_EXPORT DescribePolicyInstancesStatusResult : public ServiceResult
+			{
+			public:
+				struct Policies
+				{
+					struct PolicyInstance
+					{
+						struct PolicyCluster
+						{
+							std::string status;
+							std::string clusterId;
+						};
+						std::string policyDescription;
+						std::vector<PolicyInstance::PolicyCluster> policyClusters;
+						std::string policyName;
+						std::string policyCategory;
+						long policyInstancesCount;
+						std::string policySeverity;
+					};
+					struct SeverityInfoItem
+					{
+						std::string severityType;
+						std::string severityCount;
+					};
+					std::vector<SeverityInfoItem> severityInfo;
+					std::vector<PolicyInstance> policyInstances;
+				};
+
+
+				DescribePolicyInstancesStatusResult();
+				explicit DescribePolicyInstancesStatusResult(const std::string &payload);
+				~DescribePolicyInstancesStatusResult();
+				Policies getPolicies()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Policies policies_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSRESULT_H_

adcp/include/alibabacloud/adcp/model/DescribeRegionsRequest.h

@@ -0,0 +1,42 @@
+/*
+ * 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_ADCP_MODEL_DESCRIBEREGIONSREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEREGIONSREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DescribeRegionsRequest : public RpcServiceRequest {
+public:
+	DescribeRegionsRequest();
+	~DescribeRegionsRequest();
+	std::string getLanguage() const;
+	void setLanguage(const std::string &language);
+
+private:
+	std::string language_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEREGIONSREQUEST_H_

adcp/include/alibabacloud/adcp/model/DescribeRegionsResult.h

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

adcp/include/alibabacloud/adcp/model/DescribeUserPermissionsRequest.h

@@ -0,0 +1,42 @@
+/*
+ * 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_ADCP_MODEL_DESCRIBEUSERPERMISSIONSREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEUSERPERMISSIONSREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DescribeUserPermissionsRequest : public RpcServiceRequest {
+public:
+	DescribeUserPermissionsRequest();
+	~DescribeUserPermissionsRequest();
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+
+private:
+	std::string userId_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEUSERPERMISSIONSREQUEST_H_

adcp/include/alibabacloud/adcp/model/DescribeUserPermissionsResult.h

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

adcp/include/alibabacloud/adcp/model/DetachClusterFromHubRequest.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_ADCP_MODEL_DETACHCLUSTERFROMHUBREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_DETACHCLUSTERFROMHUBREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT DetachClusterFromHubRequest : public RpcServiceRequest {
+public:
+	DetachClusterFromHubRequest();
+	~DetachClusterFromHubRequest();
+	bool getDetachFromMesh() const;
+	void setDetachFromMesh(bool detachFromMesh);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getClusterIds() const;
+	void setClusterIds(const std::string &clusterIds);
+
+private:
+	bool detachFromMesh_;
+	std::string clusterId_;
+	std::string clusterIds_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_DETACHCLUSTERFROMHUBREQUEST_H_

adcp/include/alibabacloud/adcp/model/DetachClusterFromHubResult.h

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

adcp/include/alibabacloud/adcp/model/GrantUserPermissionRequest.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_ADCP_MODEL_GRANTUSERPERMISSIONREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT GrantUserPermissionRequest : public RpcServiceRequest {
+public:
+	GrantUserPermissionRequest();
+	~GrantUserPermissionRequest();
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	bool getIsRamRole() const;
+	void setIsRamRole(bool isRamRole);
+	std::string getRoleType() const;
+	void setRoleType(const std::string &roleType);
+	std::string getRoleName() const;
+	void setRoleName(const std::string &roleName);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+
+private:
+	std::string userId_;
+	bool isRamRole_;
+	std::string roleType_;
+	std::string roleName_;
+	std::string clusterId_;
+	std::string _namespace_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONREQUEST_H_

adcp/include/alibabacloud/adcp/model/GrantUserPermissionResult.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_ADCP_MODEL_GRANTUSERPERMISSIONRESULT_H_
+#define ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/adcp/AdcpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Adcp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADCP_EXPORT GrantUserPermissionResult : public ServiceResult
+			{
+			public:
+
+
+				GrantUserPermissionResult();
+				explicit GrantUserPermissionResult(const std::string &payload);
+				~GrantUserPermissionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONRESULT_H_

adcp/include/alibabacloud/adcp/model/GrantUserPermissionsRequest.h

@@ -0,0 +1,52 @@
+/*
+ * 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_ADCP_MODEL_GRANTUSERPERMISSIONSREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONSREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT GrantUserPermissionsRequest : public RpcServiceRequest {
+public:
+	struct Permissions {
+		bool isRamRole;
+		std::string roleName;
+		std::string _namespace;
+		std::string roleType;
+		std::string clusterId;
+	};
+	GrantUserPermissionsRequest();
+	~GrantUserPermissionsRequest();
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::vector<Permissions> getPermissions() const;
+	void setPermissions(const std::vector<Permissions> &permissions);
+
+private:
+	std::string userId_;
+	std::vector<Permissions> permissions_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONSREQUEST_H_

adcp/include/alibabacloud/adcp/model/GrantUserPermissionsResult.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_ADCP_MODEL_GRANTUSERPERMISSIONSRESULT_H_
+#define ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/adcp/AdcpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Adcp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADCP_EXPORT GrantUserPermissionsResult : public ServiceResult
+			{
+			public:
+
+
+				GrantUserPermissionsResult();
+				explicit GrantUserPermissionsResult(const std::string &payload);
+				~GrantUserPermissionsResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONSRESULT_H_

adcp/include/alibabacloud/adcp/model/UpdateHubClusterFeatureRequest.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADCP_MODEL_UPDATEHUBCLUSTERFEATUREREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_UPDATEHUBCLUSTERFEATUREREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT UpdateHubClusterFeatureRequest : public RpcServiceRequest {
+public:
+	UpdateHubClusterFeatureRequest();
+	~UpdateHubClusterFeatureRequest();
+	std::vector<std::string> getAccessControlList() const;
+	void setAccessControlList(const std::vector<std::string> &accessControlList);
+	bool getMonitorEnabled() const;
+	void setMonitorEnabled(bool monitorEnabled);
+	bool getDeletionProtection() const;
+	void setDeletionProtection(bool deletionProtection);
+	bool getEnableMesh() const;
+	void setEnableMesh(bool enableMesh);
+	bool getArgoCDHAEnabled() const;
+	void setArgoCDHAEnabled(bool argoCDHAEnabled);
+	bool getArgoCDEnabled() const;
+	void setArgoCDEnabled(bool argoCDEnabled);
+	std::vector<std::string> getVSwitches() const;
+	void setVSwitches(const std::vector<std::string> &vSwitches);
+	std::string getName() const;
+	void setName(const std::string &name);
+	bool getPublicAccessEnabled() const;
+	void setPublicAccessEnabled(bool publicAccessEnabled);
+	bool getPublicApiServerEnabled() const;
+	void setPublicApiServerEnabled(bool publicApiServerEnabled);
+	bool getArgoServerEnabled() const;
+	void setArgoServerEnabled(bool argoServerEnabled);
+	std::string getWorkflowScheduleMode() const;
+	void setWorkflowScheduleMode(const std::string &workflowScheduleMode);
+	bool getAuditLogEnabled() const;
+	void setAuditLogEnabled(bool auditLogEnabled);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getPriceLimit() const;
+	void setPriceLimit(const std::string &priceLimit);
+	std::string getApiServerEipId() const;
+	void setApiServerEipId(const std::string &apiServerEipId);
+
+private:
+	std::vector<std::string> accessControlList_;
+	bool monitorEnabled_;
+	bool deletionProtection_;
+	bool enableMesh_;
+	bool argoCDHAEnabled_;
+	bool argoCDEnabled_;
+	std::vector<std::string> vSwitches_;
+	std::string name_;
+	bool publicAccessEnabled_;
+	bool publicApiServerEnabled_;
+	bool argoServerEnabled_;
+	std::string workflowScheduleMode_;
+	bool auditLogEnabled_;
+	std::string clusterId_;
+	std::string priceLimit_;
+	std::string apiServerEipId_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_UPDATEHUBCLUSTERFEATUREREQUEST_H_

adcp/include/alibabacloud/adcp/model/UpdateHubClusterFeatureResult.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_ADCP_MODEL_UPDATEHUBCLUSTERFEATURERESULT_H_
+#define ALIBABACLOUD_ADCP_MODEL_UPDATEHUBCLUSTERFEATURERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/adcp/AdcpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Adcp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADCP_EXPORT UpdateHubClusterFeatureResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateHubClusterFeatureResult();
+				explicit UpdateHubClusterFeatureResult(const std::string &payload);
+				~UpdateHubClusterFeatureResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADCP_MODEL_UPDATEHUBCLUSTERFEATURERESULT_H_

adcp/include/alibabacloud/adcp/model/UpdateUserPermissionRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADCP_MODEL_UPDATEUSERPERMISSIONREQUEST_H_
+#define ALIBABACLOUD_ADCP_MODEL_UPDATEUSERPERMISSIONREQUEST_H_
+
+#include <alibabacloud/adcp/AdcpExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adcp {
+namespace Model {
+class ALIBABACLOUD_ADCP_EXPORT UpdateUserPermissionRequest : public RpcServiceRequest {
+public:
+	UpdateUserPermissionRequest();
+	~UpdateUserPermissionRequest();
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getRoleType() const;
+	void setRoleType(const std::string &roleType);
+	std::string getRoleName() const;
+	void setRoleName(const std::string &roleName);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+
+private:
+	std::string userId_;
+	std::string roleType_;
+	std::string roleName_;
+	std::string clusterId_;
+	std::string _namespace_;
+};
+} // namespace Model
+} // namespace Adcp
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADCP_MODEL_UPDATEUSERPERMISSIONREQUEST_H_

adcp/include/alibabacloud/adcp/model/UpdateUserPermissionResult.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_ADCP_MODEL_UPDATEUSERPERMISSIONRESULT_H_
+#define ALIBABACLOUD_ADCP_MODEL_UPDATEUSERPERMISSIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/adcp/AdcpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Adcp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADCP_EXPORT UpdateUserPermissionResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateUserPermissionResult();
+				explicit UpdateUserPermissionResult(const std::string &payload);
+				~UpdateUserPermissionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADCP_MODEL_UPDATEUSERPERMISSIONRESULT_H_

adcp/src/AdcpClient.cc

@@ -0,0 +1,881 @@
+/*
+ * 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/adcp/AdcpClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Adcp;
+using namespace AlibabaCloud::Adcp::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "adcp";
+}
+
+AdcpClient::AdcpClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "adcp");
+}
+
+AdcpClient::AdcpClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "adcp");
+}
+
+AdcpClient::AdcpClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "adcp");
+}
+
+AdcpClient::~AdcpClient()
+{}
+
+AdcpClient::AttachClusterToHubOutcome AdcpClient::attachClusterToHub(const AttachClusterToHubRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AttachClusterToHubOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AttachClusterToHubOutcome(AttachClusterToHubResult(outcome.result()));
+	else
+		return AttachClusterToHubOutcome(outcome.error());
+}
+
+void AdcpClient::attachClusterToHubAsync(const AttachClusterToHubRequest& request, const AttachClusterToHubAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, attachClusterToHub(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::AttachClusterToHubOutcomeCallable AdcpClient::attachClusterToHubCallable(const AttachClusterToHubRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AttachClusterToHubOutcome()>>(
+			[this, request]()
+			{
+			return this->attachClusterToHub(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::CreateHubClusterOutcome AdcpClient::createHubCluster(const CreateHubClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateHubClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateHubClusterOutcome(CreateHubClusterResult(outcome.result()));
+	else
+		return CreateHubClusterOutcome(outcome.error());
+}
+
+void AdcpClient::createHubClusterAsync(const CreateHubClusterRequest& request, const CreateHubClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createHubCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::CreateHubClusterOutcomeCallable AdcpClient::createHubClusterCallable(const CreateHubClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateHubClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->createHubCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DeleteHubClusterOutcome AdcpClient::deleteHubCluster(const DeleteHubClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteHubClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteHubClusterOutcome(DeleteHubClusterResult(outcome.result()));
+	else
+		return DeleteHubClusterOutcome(outcome.error());
+}
+
+void AdcpClient::deleteHubClusterAsync(const DeleteHubClusterRequest& request, const DeleteHubClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteHubCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DeleteHubClusterOutcomeCallable AdcpClient::deleteHubClusterCallable(const DeleteHubClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteHubClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteHubCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DeletePolicyInstanceOutcome AdcpClient::deletePolicyInstance(const DeletePolicyInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeletePolicyInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeletePolicyInstanceOutcome(DeletePolicyInstanceResult(outcome.result()));
+	else
+		return DeletePolicyInstanceOutcome(outcome.error());
+}
+
+void AdcpClient::deletePolicyInstanceAsync(const DeletePolicyInstanceRequest& request, const DeletePolicyInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deletePolicyInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DeletePolicyInstanceOutcomeCallable AdcpClient::deletePolicyInstanceCallable(const DeletePolicyInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeletePolicyInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->deletePolicyInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DeleteUserPermissionOutcome AdcpClient::deleteUserPermission(const DeleteUserPermissionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteUserPermissionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteUserPermissionOutcome(DeleteUserPermissionResult(outcome.result()));
+	else
+		return DeleteUserPermissionOutcome(outcome.error());
+}
+
+void AdcpClient::deleteUserPermissionAsync(const DeleteUserPermissionRequest& request, const DeleteUserPermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteUserPermission(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DeleteUserPermissionOutcomeCallable AdcpClient::deleteUserPermissionCallable(const DeleteUserPermissionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteUserPermissionOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteUserPermission(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DeployPolicyInstanceOutcome AdcpClient::deployPolicyInstance(const DeployPolicyInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeployPolicyInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeployPolicyInstanceOutcome(DeployPolicyInstanceResult(outcome.result()));
+	else
+		return DeployPolicyInstanceOutcome(outcome.error());
+}
+
+void AdcpClient::deployPolicyInstanceAsync(const DeployPolicyInstanceRequest& request, const DeployPolicyInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deployPolicyInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DeployPolicyInstanceOutcomeCallable AdcpClient::deployPolicyInstanceCallable(const DeployPolicyInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeployPolicyInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->deployPolicyInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DescribeHubClusterDetailsOutcome AdcpClient::describeHubClusterDetails(const DescribeHubClusterDetailsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeHubClusterDetailsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeHubClusterDetailsOutcome(DescribeHubClusterDetailsResult(outcome.result()));
+	else
+		return DescribeHubClusterDetailsOutcome(outcome.error());
+}
+
+void AdcpClient::describeHubClusterDetailsAsync(const DescribeHubClusterDetailsRequest& request, const DescribeHubClusterDetailsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeHubClusterDetails(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DescribeHubClusterDetailsOutcomeCallable AdcpClient::describeHubClusterDetailsCallable(const DescribeHubClusterDetailsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeHubClusterDetailsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeHubClusterDetails(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DescribeHubClusterKubeconfigOutcome AdcpClient::describeHubClusterKubeconfig(const DescribeHubClusterKubeconfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeHubClusterKubeconfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeHubClusterKubeconfigOutcome(DescribeHubClusterKubeconfigResult(outcome.result()));
+	else
+		return DescribeHubClusterKubeconfigOutcome(outcome.error());
+}
+
+void AdcpClient::describeHubClusterKubeconfigAsync(const DescribeHubClusterKubeconfigRequest& request, const DescribeHubClusterKubeconfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeHubClusterKubeconfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DescribeHubClusterKubeconfigOutcomeCallable AdcpClient::describeHubClusterKubeconfigCallable(const DescribeHubClusterKubeconfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeHubClusterKubeconfigOutcome()>>(
+			[this, request]()
+			{
+			return this->describeHubClusterKubeconfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DescribeHubClusterLogsOutcome AdcpClient::describeHubClusterLogs(const DescribeHubClusterLogsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeHubClusterLogsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeHubClusterLogsOutcome(DescribeHubClusterLogsResult(outcome.result()));
+	else
+		return DescribeHubClusterLogsOutcome(outcome.error());
+}
+
+void AdcpClient::describeHubClusterLogsAsync(const DescribeHubClusterLogsRequest& request, const DescribeHubClusterLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeHubClusterLogs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DescribeHubClusterLogsOutcomeCallable AdcpClient::describeHubClusterLogsCallable(const DescribeHubClusterLogsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeHubClusterLogsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeHubClusterLogs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DescribeHubClustersOutcome AdcpClient::describeHubClusters(const DescribeHubClustersRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeHubClustersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeHubClustersOutcome(DescribeHubClustersResult(outcome.result()));
+	else
+		return DescribeHubClustersOutcome(outcome.error());
+}
+
+void AdcpClient::describeHubClustersAsync(const DescribeHubClustersRequest& request, const DescribeHubClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeHubClusters(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DescribeHubClustersOutcomeCallable AdcpClient::describeHubClustersCallable(const DescribeHubClustersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeHubClustersOutcome()>>(
+			[this, request]()
+			{
+			return this->describeHubClusters(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DescribeManagedClustersOutcome AdcpClient::describeManagedClusters(const DescribeManagedClustersRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeManagedClustersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeManagedClustersOutcome(DescribeManagedClustersResult(outcome.result()));
+	else
+		return DescribeManagedClustersOutcome(outcome.error());
+}
+
+void AdcpClient::describeManagedClustersAsync(const DescribeManagedClustersRequest& request, const DescribeManagedClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeManagedClusters(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DescribeManagedClustersOutcomeCallable AdcpClient::describeManagedClustersCallable(const DescribeManagedClustersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeManagedClustersOutcome()>>(
+			[this, request]()
+			{
+			return this->describeManagedClusters(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DescribePoliciesOutcome AdcpClient::describePolicies(const DescribePoliciesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePoliciesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePoliciesOutcome(DescribePoliciesResult(outcome.result()));
+	else
+		return DescribePoliciesOutcome(outcome.error());
+}
+
+void AdcpClient::describePoliciesAsync(const DescribePoliciesRequest& request, const DescribePoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePolicies(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DescribePoliciesOutcomeCallable AdcpClient::describePoliciesCallable(const DescribePoliciesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePoliciesOutcome()>>(
+			[this, request]()
+			{
+			return this->describePolicies(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DescribePolicyDetailsOutcome AdcpClient::describePolicyDetails(const DescribePolicyDetailsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePolicyDetailsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePolicyDetailsOutcome(DescribePolicyDetailsResult(outcome.result()));
+	else
+		return DescribePolicyDetailsOutcome(outcome.error());
+}
+
+void AdcpClient::describePolicyDetailsAsync(const DescribePolicyDetailsRequest& request, const DescribePolicyDetailsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePolicyDetails(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DescribePolicyDetailsOutcomeCallable AdcpClient::describePolicyDetailsCallable(const DescribePolicyDetailsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePolicyDetailsOutcome()>>(
+			[this, request]()
+			{
+			return this->describePolicyDetails(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DescribePolicyGovernanceInClusterOutcome AdcpClient::describePolicyGovernanceInCluster(const DescribePolicyGovernanceInClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePolicyGovernanceInClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePolicyGovernanceInClusterOutcome(DescribePolicyGovernanceInClusterResult(outcome.result()));
+	else
+		return DescribePolicyGovernanceInClusterOutcome(outcome.error());
+}
+
+void AdcpClient::describePolicyGovernanceInClusterAsync(const DescribePolicyGovernanceInClusterRequest& request, const DescribePolicyGovernanceInClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePolicyGovernanceInCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DescribePolicyGovernanceInClusterOutcomeCallable AdcpClient::describePolicyGovernanceInClusterCallable(const DescribePolicyGovernanceInClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePolicyGovernanceInClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->describePolicyGovernanceInCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DescribePolicyInstancesOutcome AdcpClient::describePolicyInstances(const DescribePolicyInstancesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePolicyInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePolicyInstancesOutcome(DescribePolicyInstancesResult(outcome.result()));
+	else
+		return DescribePolicyInstancesOutcome(outcome.error());
+}
+
+void AdcpClient::describePolicyInstancesAsync(const DescribePolicyInstancesRequest& request, const DescribePolicyInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePolicyInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DescribePolicyInstancesOutcomeCallable AdcpClient::describePolicyInstancesCallable(const DescribePolicyInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePolicyInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->describePolicyInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DescribePolicyInstancesStatusOutcome AdcpClient::describePolicyInstancesStatus(const DescribePolicyInstancesStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePolicyInstancesStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePolicyInstancesStatusOutcome(DescribePolicyInstancesStatusResult(outcome.result()));
+	else
+		return DescribePolicyInstancesStatusOutcome(outcome.error());
+}
+
+void AdcpClient::describePolicyInstancesStatusAsync(const DescribePolicyInstancesStatusRequest& request, const DescribePolicyInstancesStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePolicyInstancesStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DescribePolicyInstancesStatusOutcomeCallable AdcpClient::describePolicyInstancesStatusCallable(const DescribePolicyInstancesStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePolicyInstancesStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->describePolicyInstancesStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DescribeRegionsOutcome AdcpClient::describeRegions(const DescribeRegionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRegionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRegionsOutcome(DescribeRegionsResult(outcome.result()));
+	else
+		return DescribeRegionsOutcome(outcome.error());
+}
+
+void AdcpClient::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRegions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DescribeRegionsOutcomeCallable AdcpClient::describeRegionsCallable(const DescribeRegionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRegionsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRegions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DescribeUserPermissionsOutcome AdcpClient::describeUserPermissions(const DescribeUserPermissionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeUserPermissionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeUserPermissionsOutcome(DescribeUserPermissionsResult(outcome.result()));
+	else
+		return DescribeUserPermissionsOutcome(outcome.error());
+}
+
+void AdcpClient::describeUserPermissionsAsync(const DescribeUserPermissionsRequest& request, const DescribeUserPermissionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeUserPermissions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DescribeUserPermissionsOutcomeCallable AdcpClient::describeUserPermissionsCallable(const DescribeUserPermissionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeUserPermissionsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeUserPermissions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::DetachClusterFromHubOutcome AdcpClient::detachClusterFromHub(const DetachClusterFromHubRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetachClusterFromHubOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetachClusterFromHubOutcome(DetachClusterFromHubResult(outcome.result()));
+	else
+		return DetachClusterFromHubOutcome(outcome.error());
+}
+
+void AdcpClient::detachClusterFromHubAsync(const DetachClusterFromHubRequest& request, const DetachClusterFromHubAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detachClusterFromHub(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::DetachClusterFromHubOutcomeCallable AdcpClient::detachClusterFromHubCallable(const DetachClusterFromHubRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetachClusterFromHubOutcome()>>(
+			[this, request]()
+			{
+			return this->detachClusterFromHub(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::GrantUserPermissionOutcome AdcpClient::grantUserPermission(const GrantUserPermissionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GrantUserPermissionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GrantUserPermissionOutcome(GrantUserPermissionResult(outcome.result()));
+	else
+		return GrantUserPermissionOutcome(outcome.error());
+}
+
+void AdcpClient::grantUserPermissionAsync(const GrantUserPermissionRequest& request, const GrantUserPermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, grantUserPermission(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::GrantUserPermissionOutcomeCallable AdcpClient::grantUserPermissionCallable(const GrantUserPermissionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GrantUserPermissionOutcome()>>(
+			[this, request]()
+			{
+			return this->grantUserPermission(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::GrantUserPermissionsOutcome AdcpClient::grantUserPermissions(const GrantUserPermissionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GrantUserPermissionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GrantUserPermissionsOutcome(GrantUserPermissionsResult(outcome.result()));
+	else
+		return GrantUserPermissionsOutcome(outcome.error());
+}
+
+void AdcpClient::grantUserPermissionsAsync(const GrantUserPermissionsRequest& request, const GrantUserPermissionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, grantUserPermissions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::GrantUserPermissionsOutcomeCallable AdcpClient::grantUserPermissionsCallable(const GrantUserPermissionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GrantUserPermissionsOutcome()>>(
+			[this, request]()
+			{
+			return this->grantUserPermissions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::UpdateHubClusterFeatureOutcome AdcpClient::updateHubClusterFeature(const UpdateHubClusterFeatureRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateHubClusterFeatureOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateHubClusterFeatureOutcome(UpdateHubClusterFeatureResult(outcome.result()));
+	else
+		return UpdateHubClusterFeatureOutcome(outcome.error());
+}
+
+void AdcpClient::updateHubClusterFeatureAsync(const UpdateHubClusterFeatureRequest& request, const UpdateHubClusterFeatureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateHubClusterFeature(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::UpdateHubClusterFeatureOutcomeCallable AdcpClient::updateHubClusterFeatureCallable(const UpdateHubClusterFeatureRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateHubClusterFeatureOutcome()>>(
+			[this, request]()
+			{
+			return this->updateHubClusterFeature(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdcpClient::UpdateUserPermissionOutcome AdcpClient::updateUserPermission(const UpdateUserPermissionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateUserPermissionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateUserPermissionOutcome(UpdateUserPermissionResult(outcome.result()));
+	else
+		return UpdateUserPermissionOutcome(outcome.error());
+}
+
+void AdcpClient::updateUserPermissionAsync(const UpdateUserPermissionRequest& request, const UpdateUserPermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateUserPermission(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdcpClient::UpdateUserPermissionOutcomeCallable AdcpClient::updateUserPermissionCallable(const UpdateUserPermissionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateUserPermissionOutcome()>>(
+			[this, request]()
+			{
+			return this->updateUserPermission(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

adcp/src/model/AttachClusterToHubRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/adcp/model/AttachClusterToHubRequest.h>
+
+using AlibabaCloud::Adcp::Model::AttachClusterToHubRequest;
+
+AttachClusterToHubRequest::AttachClusterToHubRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "AttachClusterToHub") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AttachClusterToHubRequest::~AttachClusterToHubRequest() {}
+
+std::string AttachClusterToHubRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void AttachClusterToHubRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string AttachClusterToHubRequest::getClusterIds() const {
+  return clusterIds_;
+}
+
+void AttachClusterToHubRequest::setClusterIds(const std::string &clusterIds) {
+  clusterIds_ = clusterIds;
+  setBodyParameter(std::string("ClusterIds"), clusterIds);
+}
+
+bool AttachClusterToHubRequest::getAttachToMesh() const {
+  return attachToMesh_;
+}
+
+void AttachClusterToHubRequest::setAttachToMesh(bool attachToMesh) {
+  attachToMesh_ = attachToMesh;
+  setParameter(std::string("AttachToMesh"), attachToMesh ? "true" : "false");
+}
+

adcp/src/model/AttachClusterToHubResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/adcp/model/AttachClusterToHubResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adcp;
+using namespace AlibabaCloud::Adcp::Model;
+
+AttachClusterToHubResult::AttachClusterToHubResult() :
+	ServiceResult()
+{}
+
+AttachClusterToHubResult::AttachClusterToHubResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AttachClusterToHubResult::~AttachClusterToHubResult()
+{}
+
+void AttachClusterToHubResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allManagedClusterIds = value["ManagedClusterIds"]["ManagedClusterId"];
+	for (const auto &item : allManagedClusterIds)
+		managedClusterIds_.push_back(item.asString());
+	if(!value["ClusterId"].isNull())
+		clusterId_ = value["ClusterId"].asString();
+	if(!value["TaskId"].isNull())
+		taskId_ = value["TaskId"].asString();
+
+}
+
+std::string AttachClusterToHubResult::getTaskId()const
+{
+	return taskId_;
+}
+
+std::string AttachClusterToHubResult::getClusterId()const
+{
+	return clusterId_;
+}
+
+std::vector<std::string> AttachClusterToHubResult::getManagedClusterIds()const
+{
+	return managedClusterIds_;
+}
+

adcp/src/model/CreateHubClusterRequest.cc

@@ -0,0 +1,250 @@
+/*
+ * 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/adcp/model/CreateHubClusterRequest.h>
+
+using AlibabaCloud::Adcp::Model::CreateHubClusterRequest;
+
+CreateHubClusterRequest::CreateHubClusterRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "CreateHubCluster") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateHubClusterRequest::~CreateHubClusterRequest() {}
+
+std::string CreateHubClusterRequest::getAuditLogProject() const {
+  return auditLogProject_;
+}
+
+void CreateHubClusterRequest::setAuditLogProject(const std::string &auditLogProject) {
+  auditLogProject_ = auditLogProject;
+  setBodyParameter(std::string("AuditLogProject"), auditLogProject);
+}
+
+std::string CreateHubClusterRequest::getLoadBalancerSpec() const {
+  return loadBalancerSpec_;
+}
+
+void CreateHubClusterRequest::setLoadBalancerSpec(const std::string &loadBalancerSpec) {
+  loadBalancerSpec_ = loadBalancerSpec;
+  setBodyParameter(std::string("LoadBalancerSpec"), loadBalancerSpec);
+}
+
+std::string CreateHubClusterRequest::getKubernetesVersion() const {
+  return kubernetesVersion_;
+}
+
+void CreateHubClusterRequest::setKubernetesVersion(const std::string &kubernetesVersion) {
+  kubernetesVersion_ = kubernetesVersion;
+  setBodyParameter(std::string("KubernetesVersion"), kubernetesVersion);
+}
+
+std::string CreateHubClusterRequest::getProfile() const {
+  return profile_;
+}
+
+void CreateHubClusterRequest::setProfile(const std::string &profile) {
+  profile_ = profile;
+  setBodyParameter(std::string("Profile"), profile);
+}
+
+std::string CreateHubClusterRequest::getVSwitches() const {
+  return vSwitches_;
+}
+
+void CreateHubClusterRequest::setVSwitches(const std::string &vSwitches) {
+  vSwitches_ = vSwitches;
+  setBodyParameter(std::string("VSwitches"), vSwitches);
+}
+
+std::string CreateHubClusterRequest::getControlPlaneLogProject() const {
+  return controlPlaneLogProject_;
+}
+
+void CreateHubClusterRequest::setControlPlaneLogProject(const std::string &controlPlaneLogProject) {
+  controlPlaneLogProject_ = controlPlaneLogProject;
+  setBodyParameter(std::string("ControlPlaneLogProject"), controlPlaneLogProject);
+}
+
+std::string CreateHubClusterRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void CreateHubClusterRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setBodyParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+
+std::string CreateHubClusterRequest::getClusterSpec() const {
+  return clusterSpec_;
+}
+
+void CreateHubClusterRequest::setClusterSpec(const std::string &clusterSpec) {
+  clusterSpec_ = clusterSpec;
+  setBodyParameter(std::string("ClusterSpec"), clusterSpec);
+}
+
+std::string CreateHubClusterRequest::getName() const {
+  return name_;
+}
+
+void CreateHubClusterRequest::setName(const std::string &name) {
+  name_ = name;
+  setBodyParameter(std::string("Name"), name);
+}
+
+std::string CreateHubClusterRequest::getClusterDomain() const {
+  return clusterDomain_;
+}
+
+void CreateHubClusterRequest::setClusterDomain(const std::string &clusterDomain) {
+  clusterDomain_ = clusterDomain;
+  setBodyParameter(std::string("ClusterDomain"), clusterDomain);
+}
+
+std::string CreateHubClusterRequest::getControlPlaneLogTTL() const {
+  return controlPlaneLogTTL_;
+}
+
+void CreateHubClusterRequest::setControlPlaneLogTTL(const std::string &controlPlaneLogTTL) {
+  controlPlaneLogTTL_ = controlPlaneLogTTL;
+  setBodyParameter(std::string("ControlPlaneLogTTL"), controlPlaneLogTTL);
+}
+
+std::vector<CreateHubClusterRequest::WorkflowUnits> CreateHubClusterRequest::getWorkflowUnits() const {
+  return workflowUnits_;
+}
+
+void CreateHubClusterRequest::setWorkflowUnits(const std::vector<CreateHubClusterRequest::WorkflowUnits> &workflowUnits) {
+  workflowUnits_ = workflowUnits;
+  for(int dep1 = 0; dep1 != workflowUnits.size(); dep1++) {
+    setBodyParameter(std::string("WorkflowUnits") + "." + std::to_string(dep1 + 1) + ".RegionId", workflowUnits[dep1].regionId);
+    setBodyParameter(std::string("WorkflowUnits") + "." + std::to_string(dep1 + 1) + ".VpcId", workflowUnits[dep1].vpcId);
+    for(int dep2 = 0; dep2 != workflowUnits[dep1].vSwitches.size(); dep2++) {
+      setBodyParameter(std::string("WorkflowUnits") + "." + std::to_string(dep1 + 1) + ".VSwitches." + std::to_string(dep2 + 1) + ".VswitchId", workflowUnits[dep1].vSwitches[dep2].vswitchId);
+      setBodyParameter(std::string("WorkflowUnits") + "." + std::to_string(dep1 + 1) + ".VSwitches." + std::to_string(dep2 + 1) + ".ZoneId", workflowUnits[dep1].vSwitches[dep2].zoneId);
+    }
+  }
+}
+
+std::string CreateHubClusterRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateHubClusterRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setBodyParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateHubClusterRequest::getAuditLogStoreTTL() const {
+  return auditLogStoreTTL_;
+}
+
+void CreateHubClusterRequest::setAuditLogStoreTTL(const std::string &auditLogStoreTTL) {
+  auditLogStoreTTL_ = auditLogStoreTTL;
+  setBodyParameter(std::string("AuditLogStoreTTL"), auditLogStoreTTL);
+}
+
+std::string CreateHubClusterRequest::getIPStack() const {
+  return iPStack_;
+}
+
+void CreateHubClusterRequest::setIPStack(const std::string &iPStack) {
+  iPStack_ = iPStack;
+  setBodyParameter(std::string("IPStack"), iPStack);
+}
+
+bool CreateHubClusterRequest::getControlPlaneLogEnabled() const {
+  return controlPlaneLogEnabled_;
+}
+
+void CreateHubClusterRequest::setControlPlaneLogEnabled(bool controlPlaneLogEnabled) {
+  controlPlaneLogEnabled_ = controlPlaneLogEnabled;
+  setBodyParameter(std::string("ControlPlaneLogEnabled"), controlPlaneLogEnabled ? "true" : "false");
+}
+
+bool CreateHubClusterRequest::getArgoServerEnabled() const {
+  return argoServerEnabled_;
+}
+
+void CreateHubClusterRequest::setArgoServerEnabled(bool argoServerEnabled) {
+  argoServerEnabled_ = argoServerEnabled;
+  setBodyParameter(std::string("ArgoServerEnabled"), argoServerEnabled ? "true" : "false");
+}
+
+std::string CreateHubClusterRequest::getWorkflowScheduleMode() const {
+  return workflowScheduleMode_;
+}
+
+void CreateHubClusterRequest::setWorkflowScheduleMode(const std::string &workflowScheduleMode) {
+  workflowScheduleMode_ = workflowScheduleMode;
+  setBodyParameter(std::string("WorkflowScheduleMode"), workflowScheduleMode);
+}
+
+bool CreateHubClusterRequest::getApiServerPublicEip() const {
+  return apiServerPublicEip_;
+}
+
+void CreateHubClusterRequest::setApiServerPublicEip(bool apiServerPublicEip) {
+  apiServerPublicEip_ = apiServerPublicEip;
+  setBodyParameter(std::string("ApiServerPublicEip"), apiServerPublicEip ? "true" : "false");
+}
+
+bool CreateHubClusterRequest::getAuditLogEnabled() const {
+  return auditLogEnabled_;
+}
+
+void CreateHubClusterRequest::setAuditLogEnabled(bool auditLogEnabled) {
+  auditLogEnabled_ = auditLogEnabled;
+  setBodyParameter(std::string("AuditLogEnabled"), auditLogEnabled ? "true" : "false");
+}
+
+std::string CreateHubClusterRequest::getSecurityGroupIDs() const {
+  return securityGroupIDs_;
+}
+
+void CreateHubClusterRequest::setSecurityGroupIDs(const std::string &securityGroupIDs) {
+  securityGroupIDs_ = securityGroupIDs;
+  setBodyParameter(std::string("SecurityGroupIDs"), securityGroupIDs);
+}
+
+std::string CreateHubClusterRequest::getPriceLimit() const {
+  return priceLimit_;
+}
+
+void CreateHubClusterRequest::setPriceLimit(const std::string &priceLimit) {
+  priceLimit_ = priceLimit;
+  setBodyParameter(std::string("PriceLimit"), priceLimit);
+}
+
+bool CreateHubClusterRequest::getIsEnterpriseSecurityGroup() const {
+  return isEnterpriseSecurityGroup_;
+}
+
+void CreateHubClusterRequest::setIsEnterpriseSecurityGroup(bool isEnterpriseSecurityGroup) {
+  isEnterpriseSecurityGroup_ = isEnterpriseSecurityGroup;
+  setBodyParameter(std::string("IsEnterpriseSecurityGroup"), isEnterpriseSecurityGroup ? "true" : "false");
+}
+
+std::string CreateHubClusterRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void CreateHubClusterRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setBodyParameter(std::string("VpcId"), vpcId);
+}
+

adcp/src/model/CreateHubClusterResult.cc

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

adcp/src/model/DeleteHubClusterRequest.cc

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/adcp/model/DeleteHubClusterRequest.h>
+
+using AlibabaCloud::Adcp::Model::DeleteHubClusterRequest;
+
+DeleteHubClusterRequest::DeleteHubClusterRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "DeleteHubCluster") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteHubClusterRequest::~DeleteHubClusterRequest() {}
+
+std::vector<DeleteHubClusterRequest::std::string> DeleteHubClusterRequest::getRetainResources() const {
+  return retainResources_;
+}
+
+void DeleteHubClusterRequest::setRetainResources(const std::vector<DeleteHubClusterRequest::std::string> &retainResources) {
+  retainResources_ = retainResources;
+  for(int dep1 = 0; dep1 != retainResources.size(); dep1++) {
+    setParameter(std::string("RetainResources") + "." + std::to_string(dep1 + 1), retainResources[dep1]);
+  }
+}
+
+std::string DeleteHubClusterRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DeleteHubClusterRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+bool DeleteHubClusterRequest::getForce() const {
+  return force_;
+}
+
+void DeleteHubClusterRequest::setForce(bool force) {
+  force_ = force;
+  setParameter(std::string("Force"), force ? "true" : "false");
+}
+

adcp/src/model/DeleteHubClusterResult.cc

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

adcp/src/model/DeletePolicyInstanceRequest.cc

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/adcp/model/DeletePolicyInstanceRequest.h>
+
+using AlibabaCloud::Adcp::Model::DeletePolicyInstanceRequest;
+
+DeletePolicyInstanceRequest::DeletePolicyInstanceRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "DeletePolicyInstance") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeletePolicyInstanceRequest::~DeletePolicyInstanceRequest() {}
+
+std::string DeletePolicyInstanceRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DeletePolicyInstanceRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::vector<DeletePolicyInstanceRequest::std::string> DeletePolicyInstanceRequest::getClusterIds() const {
+  return clusterIds_;
+}
+
+void DeletePolicyInstanceRequest::setClusterIds(const std::vector<DeletePolicyInstanceRequest::std::string> &clusterIds) {
+  clusterIds_ = clusterIds;
+  for(int dep1 = 0; dep1 != clusterIds.size(); dep1++) {
+    setParameter(std::string("ClusterIds") + "." + std::to_string(dep1 + 1), clusterIds[dep1]);
+  }
+}
+
+std::string DeletePolicyInstanceRequest::getPolicyName() const {
+  return policyName_;
+}
+
+void DeletePolicyInstanceRequest::setPolicyName(const std::string &policyName) {
+  policyName_ = policyName;
+  setParameter(std::string("PolicyName"), policyName);
+}
+

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

adcp/src/model/DeleteUserPermissionRequest.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/adcp/model/DeleteUserPermissionRequest.h>
+
+using AlibabaCloud::Adcp::Model::DeleteUserPermissionRequest;
+
+DeleteUserPermissionRequest::DeleteUserPermissionRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "DeleteUserPermission") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteUserPermissionRequest::~DeleteUserPermissionRequest() {}
+
+std::string DeleteUserPermissionRequest::getUserId() const {
+  return userId_;
+}
+
+void DeleteUserPermissionRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string DeleteUserPermissionRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DeleteUserPermissionRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+

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

adcp/src/model/DeployPolicyInstanceRequest.cc

@@ -0,0 +1,76 @@
+/*
+ * 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/adcp/model/DeployPolicyInstanceRequest.h>
+
+using AlibabaCloud::Adcp::Model::DeployPolicyInstanceRequest;
+
+DeployPolicyInstanceRequest::DeployPolicyInstanceRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "DeployPolicyInstance") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeployPolicyInstanceRequest::~DeployPolicyInstanceRequest() {}
+
+std::string DeployPolicyInstanceRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DeployPolicyInstanceRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string DeployPolicyInstanceRequest::getPolicyAction() const {
+  return policyAction_;
+}
+
+void DeployPolicyInstanceRequest::setPolicyAction(const std::string &policyAction) {
+  policyAction_ = policyAction;
+  setParameter(std::string("PolicyAction"), policyAction);
+}
+
+std::vector<DeployPolicyInstanceRequest::std::string> DeployPolicyInstanceRequest::getClusterIds() const {
+  return clusterIds_;
+}
+
+void DeployPolicyInstanceRequest::setClusterIds(const std::vector<DeployPolicyInstanceRequest::std::string> &clusterIds) {
+  clusterIds_ = clusterIds;
+  for(int dep1 = 0; dep1 != clusterIds.size(); dep1++) {
+    setParameter(std::string("ClusterIds") + "." + std::to_string(dep1 + 1), clusterIds[dep1]);
+  }
+}
+
+std::string DeployPolicyInstanceRequest::getPolicyName() const {
+  return policyName_;
+}
+
+void DeployPolicyInstanceRequest::setPolicyName(const std::string &policyName) {
+  policyName_ = policyName;
+  setParameter(std::string("PolicyName"), policyName);
+}
+
+std::vector<DeployPolicyInstanceRequest::std::string> DeployPolicyInstanceRequest::getNamespaces() const {
+  return namespaces_;
+}
+
+void DeployPolicyInstanceRequest::setNamespaces(const std::vector<DeployPolicyInstanceRequest::std::string> &namespaces) {
+  namespaces_ = namespaces;
+  for(int dep1 = 0; dep1 != namespaces.size(); dep1++) {
+    setParameter(std::string("Namespaces") + "." + std::to_string(dep1 + 1), namespaces[dep1]);
+  }
+}
+

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

adcp/src/model/DescribeHubClusterDetailsRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * 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/adcp/model/DescribeHubClusterDetailsRequest.h>
+
+using AlibabaCloud::Adcp::Model::DescribeHubClusterDetailsRequest;
+
+DescribeHubClusterDetailsRequest::DescribeHubClusterDetailsRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "DescribeHubClusterDetails") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeHubClusterDetailsRequest::~DescribeHubClusterDetailsRequest() {}
+
+std::string DescribeHubClusterDetailsRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DescribeHubClusterDetailsRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+

adcp/src/model/DescribeHubClusterDetailsResult.cc

@@ -0,0 +1,149 @@
+/*
+ * 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/adcp/model/DescribeHubClusterDetailsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adcp;
+using namespace AlibabaCloud::Adcp::Model;
+
+DescribeHubClusterDetailsResult::DescribeHubClusterDetailsResult() :
+	ServiceResult()
+{}
+
+DescribeHubClusterDetailsResult::DescribeHubClusterDetailsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeHubClusterDetailsResult::~DescribeHubClusterDetailsResult()
+{}
+
+void DescribeHubClusterDetailsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto clusterNode = value["Cluster"];
+	auto allConditionsNode = clusterNode["Conditions"]["Condition"];
+	for (auto clusterNodeConditionsCondition : allConditionsNode)
+	{
+		Cluster::Condition conditionObject;
+		if(!clusterNodeConditionsCondition["Type"].isNull())
+			conditionObject.type = clusterNodeConditionsCondition["Type"].asString();
+		if(!clusterNodeConditionsCondition["Status"].isNull())
+			conditionObject.status = clusterNodeConditionsCondition["Status"].asString();
+		if(!clusterNodeConditionsCondition["Reason"].isNull())
+			conditionObject.reason = clusterNodeConditionsCondition["Reason"].asString();
+		if(!clusterNodeConditionsCondition["Message"].isNull())
+			conditionObject.message = clusterNodeConditionsCondition["Message"].asString();
+		cluster_.conditions.push_back(conditionObject);
+	}
+	auto endpointsNode = clusterNode["Endpoints"];
+	if(!endpointsNode["IntranetApiServerEndpoint"].isNull())
+		cluster_.endpoints.intranetApiServerEndpoint = endpointsNode["IntranetApiServerEndpoint"].asString();
+	if(!endpointsNode["PublicApiServerEndpoint"].isNull())
+		cluster_.endpoints.publicApiServerEndpoint = endpointsNode["PublicApiServerEndpoint"].asString();
+	auto clusterInfoNode = clusterNode["ClusterInfo"];
+	if(!clusterInfoNode["Profile"].isNull())
+		cluster_.clusterInfo.profile = clusterInfoNode["Profile"].asString();
+	if(!clusterInfoNode["CreationTime"].isNull())
+		cluster_.clusterInfo.creationTime = clusterInfoNode["CreationTime"].asString();
+	if(!clusterInfoNode["UpdateTime"].isNull())
+		cluster_.clusterInfo.updateTime = clusterInfoNode["UpdateTime"].asString();
+	if(!clusterInfoNode["ErrorMessage"].isNull())
+		cluster_.clusterInfo.errorMessage = clusterInfoNode["ErrorMessage"].asString();
+	if(!clusterInfoNode["Version"].isNull())
+		cluster_.clusterInfo.version = clusterInfoNode["Version"].asString();
+	if(!clusterInfoNode["State"].isNull())
+		cluster_.clusterInfo.state = clusterInfoNode["State"].asString();
+	if(!clusterInfoNode["ClusterId"].isNull())
+		cluster_.clusterInfo.clusterId = clusterInfoNode["ClusterId"].asString();
+	if(!clusterInfoNode["Name"].isNull())
+		cluster_.clusterInfo.name = clusterInfoNode["Name"].asString();
+	if(!clusterInfoNode["RegionId"].isNull())
+		cluster_.clusterInfo.regionId = clusterInfoNode["RegionId"].asString();
+	if(!clusterInfoNode["ClusterSpec"].isNull())
+		cluster_.clusterInfo.clusterSpec = clusterInfoNode["ClusterSpec"].asString();
+	auto networkNode = clusterNode["Network"];
+	if(!networkNode["VpcId"].isNull())
+		cluster_.network.vpcId = networkNode["VpcId"].asString();
+	if(!networkNode["IPStack"].isNull())
+		cluster_.network.iPStack = networkNode["IPStack"].asString();
+	if(!networkNode["ClusterDomain"].isNull())
+		cluster_.network.clusterDomain = networkNode["ClusterDomain"].asString();
+		auto allVSwitches = networkNode["VSwitches"]["VSwitches"];
+		for (auto value : allVSwitches)
+			cluster_.network.vSwitches.push_back(value.asString());
+		auto allSecurityGroupIDs = networkNode["SecurityGroupIDs"]["SecurityGroupIDs"];
+		for (auto value : allSecurityGroupIDs)
+			cluster_.network.securityGroupIDs.push_back(value.asString());
+	auto apiServerNode = clusterNode["ApiServer"];
+	if(!apiServerNode["EnabledPublic"].isNull())
+		cluster_.apiServer.enabledPublic = apiServerNode["EnabledPublic"].asString() == "true";
+	if(!apiServerNode["LoadBalancerId"].isNull())
+		cluster_.apiServer.loadBalancerId = apiServerNode["LoadBalancerId"].asString();
+	if(!apiServerNode["ApiServerEipId"].isNull())
+		cluster_.apiServer.apiServerEipId = apiServerNode["ApiServerEipId"].asString();
+	auto meshConfigNode = clusterNode["MeshConfig"];
+	if(!meshConfigNode["EnableMesh"].isNull())
+		cluster_.meshConfig.enableMesh = meshConfigNode["EnableMesh"].asString() == "true";
+	if(!meshConfigNode["MeshId"].isNull())
+		cluster_.meshConfig.meshId = meshConfigNode["MeshId"].asString();
+	auto logConfigNode = clusterNode["LogConfig"];
+	if(!logConfigNode["EnableLog"].isNull())
+		cluster_.logConfig.enableLog = logConfigNode["EnableLog"].asString() == "true";
+	if(!logConfigNode["LogProject"].isNull())
+		cluster_.logConfig.logProject = logConfigNode["LogProject"].asString();
+	if(!logConfigNode["LogStoreTTL"].isNull())
+		cluster_.logConfig.logStoreTTL = logConfigNode["LogStoreTTL"].asString();
+	auto workflowConfigNode = clusterNode["WorkflowConfig"];
+	if(!workflowConfigNode["ArgoServerEnabled"].isNull())
+		cluster_.workflowConfig.argoServerEnabled = workflowConfigNode["ArgoServerEnabled"].asString() == "true";
+	if(!workflowConfigNode["WorkflowScheduleMode"].isNull())
+		cluster_.workflowConfig.workflowScheduleMode = workflowConfigNode["WorkflowScheduleMode"].asString();
+	if(!workflowConfigNode["PriceLimit"].isNull())
+		cluster_.workflowConfig.priceLimit = workflowConfigNode["PriceLimit"].asString();
+	auto allWorkflowUnitsNode = workflowConfigNode["WorkflowUnits"]["WorkflowUnit"];
+	for (auto workflowConfigNodeWorkflowUnitsWorkflowUnit : allWorkflowUnitsNode)
+	{
+		Cluster::WorkflowConfig::WorkflowUnit workflowUnitObject;
+		if(!workflowConfigNodeWorkflowUnitsWorkflowUnit["RegionId"].isNull())
+			workflowUnitObject.regionId = workflowConfigNodeWorkflowUnitsWorkflowUnit["RegionId"].asString();
+		if(!workflowConfigNodeWorkflowUnitsWorkflowUnit["VpcId"].isNull())
+			workflowUnitObject.vpcId = workflowConfigNodeWorkflowUnitsWorkflowUnit["VpcId"].asString();
+		auto allVSwitches1Node = workflowConfigNodeWorkflowUnitsWorkflowUnit["VSwitches"]["VSwitch"];
+		for (auto workflowConfigNodeWorkflowUnitsWorkflowUnitVSwitchesVSwitch : allVSwitches1Node)
+		{
+			Cluster::WorkflowConfig::WorkflowUnit::VSwitch vSwitches1Object;
+			if(!workflowConfigNodeWorkflowUnitsWorkflowUnitVSwitchesVSwitch["VswitchId"].isNull())
+				vSwitches1Object.vswitchId = workflowConfigNodeWorkflowUnitsWorkflowUnitVSwitchesVSwitch["VswitchId"].asString();
+			if(!workflowConfigNodeWorkflowUnitsWorkflowUnitVSwitchesVSwitch["ZoneId"].isNull())
+				vSwitches1Object.zoneId = workflowConfigNodeWorkflowUnitsWorkflowUnitVSwitchesVSwitch["ZoneId"].asString();
+			workflowUnitObject.vSwitches1.push_back(vSwitches1Object);
+		}
+		cluster_.workflowConfig.workflowUnits.push_back(workflowUnitObject);
+	}
+
+}
+
+DescribeHubClusterDetailsResult::Cluster DescribeHubClusterDetailsResult::getCluster()const
+{
+	return cluster_;
+}
+

adcp/src/model/DescribeHubClusterKubeconfigRequest.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/adcp/model/DescribeHubClusterKubeconfigRequest.h>
+
+using AlibabaCloud::Adcp::Model::DescribeHubClusterKubeconfigRequest;
+
+DescribeHubClusterKubeconfigRequest::DescribeHubClusterKubeconfigRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "DescribeHubClusterKubeconfig") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeHubClusterKubeconfigRequest::~DescribeHubClusterKubeconfigRequest() {}
+
+std::string DescribeHubClusterKubeconfigRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DescribeHubClusterKubeconfigRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+bool DescribeHubClusterKubeconfigRequest::getPrivateIpAddress() const {
+  return privateIpAddress_;
+}
+
+void DescribeHubClusterKubeconfigRequest::setPrivateIpAddress(bool privateIpAddress) {
+  privateIpAddress_ = privateIpAddress;
+  setParameter(std::string("PrivateIpAddress"), privateIpAddress ? "true" : "false");
+}
+

adcp/src/model/DescribeHubClusterKubeconfigResult.cc

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

adcp/src/model/DescribeHubClusterLogsRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * 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/adcp/model/DescribeHubClusterLogsRequest.h>
+
+using AlibabaCloud::Adcp::Model::DescribeHubClusterLogsRequest;
+
+DescribeHubClusterLogsRequest::DescribeHubClusterLogsRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "DescribeHubClusterLogs") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeHubClusterLogsRequest::~DescribeHubClusterLogsRequest() {}
+
+std::string DescribeHubClusterLogsRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DescribeHubClusterLogsRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+

adcp/src/model/DescribeHubClusterLogsResult.cc

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

adcp/src/model/DescribeHubClustersRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * 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/adcp/model/DescribeHubClustersRequest.h>
+
+using AlibabaCloud::Adcp::Model::DescribeHubClustersRequest;
+
+DescribeHubClustersRequest::DescribeHubClustersRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "DescribeHubClusters") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeHubClustersRequest::~DescribeHubClustersRequest() {}
+
+std::string DescribeHubClustersRequest::getProfile() const {
+  return profile_;
+}
+
+void DescribeHubClustersRequest::setProfile(const std::string &profile) {
+  profile_ = profile;
+  setParameter(std::string("Profile"), profile);
+}
+

adcp/src/model/DescribeHubClustersResult.cc

@@ -0,0 +1,125 @@
+/*
+ * 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/adcp/model/DescribeHubClustersResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adcp;
+using namespace AlibabaCloud::Adcp::Model;
+
+DescribeHubClustersResult::DescribeHubClustersResult() :
+	ServiceResult()
+{}
+
+DescribeHubClustersResult::DescribeHubClustersResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeHubClustersResult::~DescribeHubClustersResult()
+{}
+
+void DescribeHubClustersResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allClustersNode = value["Clusters"]["Cluster"];
+	for (auto valueClustersCluster : allClustersNode)
+	{
+		Cluster clustersObject;
+		auto allConditionsNode = valueClustersCluster["Conditions"]["Condition"];
+		for (auto valueClustersClusterConditionsCondition : allConditionsNode)
+		{
+			Cluster::Condition conditionsObject;
+			if(!valueClustersClusterConditionsCondition["Type"].isNull())
+				conditionsObject.type = valueClustersClusterConditionsCondition["Type"].asString();
+			if(!valueClustersClusterConditionsCondition["Status"].isNull())
+				conditionsObject.status = valueClustersClusterConditionsCondition["Status"].asString();
+			if(!valueClustersClusterConditionsCondition["Reason"].isNull())
+				conditionsObject.reason = valueClustersClusterConditionsCondition["Reason"].asString();
+			if(!valueClustersClusterConditionsCondition["Message"].isNull())
+				conditionsObject.message = valueClustersClusterConditionsCondition["Message"].asString();
+			clustersObject.conditions.push_back(conditionsObject);
+		}
+		auto endpointsNode = value["Endpoints"];
+		if(!endpointsNode["IntranetApiServerEndpoint"].isNull())
+			clustersObject.endpoints.intranetApiServerEndpoint = endpointsNode["IntranetApiServerEndpoint"].asString();
+		if(!endpointsNode["PublicApiServerEndpoint"].isNull())
+			clustersObject.endpoints.publicApiServerEndpoint = endpointsNode["PublicApiServerEndpoint"].asString();
+		auto clusterInfoNode = value["ClusterInfo"];
+		if(!clusterInfoNode["Profile"].isNull())
+			clustersObject.clusterInfo.profile = clusterInfoNode["Profile"].asString();
+		if(!clusterInfoNode["CreationTime"].isNull())
+			clustersObject.clusterInfo.creationTime = clusterInfoNode["CreationTime"].asString();
+		if(!clusterInfoNode["UpdateTime"].isNull())
+			clustersObject.clusterInfo.updateTime = clusterInfoNode["UpdateTime"].asString();
+		if(!clusterInfoNode["ErrorMessage"].isNull())
+			clustersObject.clusterInfo.errorMessage = clusterInfoNode["ErrorMessage"].asString();
+		if(!clusterInfoNode["Version"].isNull())
+			clustersObject.clusterInfo.version = clusterInfoNode["Version"].asString();
+		if(!clusterInfoNode["State"].isNull())
+			clustersObject.clusterInfo.state = clusterInfoNode["State"].asString();
+		if(!clusterInfoNode["ClusterId"].isNull())
+			clustersObject.clusterInfo.clusterId = clusterInfoNode["ClusterId"].asString();
+		if(!clusterInfoNode["Name"].isNull())
+			clustersObject.clusterInfo.name = clusterInfoNode["Name"].asString();
+		if(!clusterInfoNode["RegionId"].isNull())
+			clustersObject.clusterInfo.regionId = clusterInfoNode["RegionId"].asString();
+		if(!clusterInfoNode["ClusterSpec"].isNull())
+			clustersObject.clusterInfo.clusterSpec = clusterInfoNode["ClusterSpec"].asString();
+		auto networkNode = value["Network"];
+		if(!networkNode["VpcId"].isNull())
+			clustersObject.network.vpcId = networkNode["VpcId"].asString();
+		if(!networkNode["ClusterDomain"].isNull())
+			clustersObject.network.clusterDomain = networkNode["ClusterDomain"].asString();
+			auto allVSwitches = networkNode["VSwitches"]["VSwitches"];
+			for (auto value : allVSwitches)
+				clustersObject.network.vSwitches.push_back(value.asString());
+			auto allSecurityGroupIDs = networkNode["SecurityGroupIDs"]["SecurityGroupIDs"];
+			for (auto value : allSecurityGroupIDs)
+				clustersObject.network.securityGroupIDs.push_back(value.asString());
+		auto apiServerNode = value["ApiServer"];
+		if(!apiServerNode["EnabledPublic"].isNull())
+			clustersObject.apiServer.enabledPublic = apiServerNode["EnabledPublic"].asString() == "true";
+		if(!apiServerNode["LoadBalancerId"].isNull())
+			clustersObject.apiServer.loadBalancerId = apiServerNode["LoadBalancerId"].asString();
+		if(!apiServerNode["ApiServerEipId"].isNull())
+			clustersObject.apiServer.apiServerEipId = apiServerNode["ApiServerEipId"].asString();
+		auto meshConfigNode = value["MeshConfig"];
+		if(!meshConfigNode["EnableMesh"].isNull())
+			clustersObject.meshConfig.enableMesh = meshConfigNode["EnableMesh"].asString() == "true";
+		if(!meshConfigNode["MeshId"].isNull())
+			clustersObject.meshConfig.meshId = meshConfigNode["MeshId"].asString();
+		auto logConfigNode = value["LogConfig"];
+		if(!logConfigNode["EnableLog"].isNull())
+			clustersObject.logConfig.enableLog = logConfigNode["EnableLog"].asString() == "true";
+		if(!logConfigNode["LogProject"].isNull())
+			clustersObject.logConfig.logProject = logConfigNode["LogProject"].asString();
+		if(!logConfigNode["LogStoreTTL"].isNull())
+			clustersObject.logConfig.logStoreTTL = logConfigNode["LogStoreTTL"].asString();
+		clusters_.push_back(clustersObject);
+	}
+
+}
+
+std::vector<DescribeHubClustersResult::Cluster> DescribeHubClustersResult::getClusters()const
+{
+	return clusters_;
+}
+

adcp/src/model/DescribeManagedClustersRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * 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/adcp/model/DescribeManagedClustersRequest.h>
+
+using AlibabaCloud::Adcp::Model::DescribeManagedClustersRequest;
+
+DescribeManagedClustersRequest::DescribeManagedClustersRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "DescribeManagedClusters") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeManagedClustersRequest::~DescribeManagedClustersRequest() {}
+
+std::string DescribeManagedClustersRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DescribeManagedClustersRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+

adcp/src/model/DescribeManagedClustersResult.cc

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/adcp/model/DescribeManagedClustersResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adcp;
+using namespace AlibabaCloud::Adcp::Model;
+
+DescribeManagedClustersResult::DescribeManagedClustersResult() :
+	ServiceResult()
+{}
+
+DescribeManagedClustersResult::DescribeManagedClustersResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeManagedClustersResult::~DescribeManagedClustersResult()
+{}
+
+void DescribeManagedClustersResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allClustersNode = value["Clusters"]["Cluster"];
+	for (auto valueClustersCluster : allClustersNode)
+	{
+		Cluster clustersObject;
+		auto cluster1Node = value["Cluster"];
+		if(!cluster1Node["Name"].isNull())
+			clustersObject.cluster1.name = cluster1Node["Name"].asString();
+		if(!cluster1Node["ClusterID"].isNull())
+			clustersObject.cluster1.clusterID = cluster1Node["ClusterID"].asString();
+		if(!cluster1Node["Region"].isNull())
+			clustersObject.cluster1.region = cluster1Node["Region"].asString();
+		if(!cluster1Node["State"].isNull())
+			clustersObject.cluster1.state = cluster1Node["State"].asString();
+		if(!cluster1Node["ClusterType"].isNull())
+			clustersObject.cluster1.clusterType = cluster1Node["ClusterType"].asString();
+		if(!cluster1Node["Created"].isNull())
+			clustersObject.cluster1.created = cluster1Node["Created"].asString();
+		if(!cluster1Node["Updated"].isNull())
+			clustersObject.cluster1.updated = cluster1Node["Updated"].asString();
+		if(!cluster1Node["InitVersion"].isNull())
+			clustersObject.cluster1.initVersion = cluster1Node["InitVersion"].asString();
+		if(!cluster1Node["CurrentVersion"].isNull())
+			clustersObject.cluster1.currentVersion = cluster1Node["CurrentVersion"].asString();
+		if(!cluster1Node["ResourceGroupId"].isNull())
+			clustersObject.cluster1.resourceGroupId = cluster1Node["ResourceGroupId"].asString();
+		if(!cluster1Node["VpcID"].isNull())
+			clustersObject.cluster1.vpcID = cluster1Node["VpcID"].asString();
+		if(!cluster1Node["VSwitchID"].isNull())
+			clustersObject.cluster1.vSwitchID = cluster1Node["VSwitchID"].asString();
+		if(!cluster1Node["Profile"].isNull())
+			clustersObject.cluster1.profile = cluster1Node["Profile"].asString();
+		if(!cluster1Node["ClusterSpec"].isNull())
+			clustersObject.cluster1.clusterSpec = cluster1Node["ClusterSpec"].asString();
+		auto statusNode = value["Status"];
+		if(!statusNode["State"].isNull())
+			clustersObject.status.state = statusNode["State"].asString();
+		if(!statusNode["Message"].isNull())
+			clustersObject.status.message = statusNode["Message"].asString();
+		auto meshStatusNode = value["MeshStatus"];
+		if(!meshStatusNode["InMesh"].isNull())
+			clustersObject.meshStatus.inMesh = meshStatusNode["InMesh"].asString() == "true";
+		clusters_.push_back(clustersObject);
+	}
+
+}
+
+std::vector<DescribeManagedClustersResult::Cluster> DescribeManagedClustersResult::getClusters()const
+{
+	return clusters_;
+}
+

adcp/src/model/DescribePoliciesRequest.cc

@@ -0,0 +1,27 @@
+/*
+ * 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/adcp/model/DescribePoliciesRequest.h>
+
+using AlibabaCloud::Adcp::Model::DescribePoliciesRequest;
+
+DescribePoliciesRequest::DescribePoliciesRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "DescribePolicies") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribePoliciesRequest::~DescribePoliciesRequest() {}
+

adcp/src/model/DescribePoliciesResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/adcp/model/DescribePoliciesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adcp;
+using namespace AlibabaCloud::Adcp::Model;
+
+DescribePoliciesResult::DescribePoliciesResult() :
+	ServiceResult()
+{}
+
+DescribePoliciesResult::DescribePoliciesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribePoliciesResult::~DescribePoliciesResult()
+{}
+
+void DescribePoliciesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allPoliciesNode = value["Policies"]["policy"];
+	for (auto valuePoliciespolicy : allPoliciesNode)
+	{
+		Policy policiesObject;
+		if(!valuePoliciespolicy["Category"].isNull())
+			policiesObject.category = valuePoliciespolicy["Category"].asString();
+		auto allNames = value["Names"]["name"];
+		for (auto value : allNames)
+			policiesObject.names.push_back(value.asString());
+		policies_.push_back(policiesObject);
+	}
+
+}
+
+std::vector<DescribePoliciesResult::Policy> DescribePoliciesResult::getPolicies()const
+{
+	return policies_;
+}
+