UpdateHubClusterFeature support ArgoCDHAEnabled.

VERSION

@@ -1 +1 @@
-1.36.1717
+1.36.1718

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_;
+}
+

adcp/src/model/DescribePolicyDetailsRequest.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/DescribePolicyDetailsRequest.h>
+
+using AlibabaCloud::Adcp::Model::DescribePolicyDetailsRequest;
+
+DescribePolicyDetailsRequest::DescribePolicyDetailsRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "DescribePolicyDetails") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribePolicyDetailsRequest::~DescribePolicyDetailsRequest() {}
+
+std::string DescribePolicyDetailsRequest::getPolicyName() const {
+  return policyName_;
+}
+
+void DescribePolicyDetailsRequest::setPolicyName(const std::string &policyName) {
+  policyName_ = policyName;
+  setParameter(std::string("PolicyName"), policyName);
+}
+

adcp/src/model/DescribePolicyDetailsResult.cc

@@ -0,0 +1,68 @@
+/*
+ * 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/DescribePolicyDetailsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adcp;
+using namespace AlibabaCloud::Adcp::Model;
+
+DescribePolicyDetailsResult::DescribePolicyDetailsResult() :
+	ServiceResult()
+{}
+
+DescribePolicyDetailsResult::DescribePolicyDetailsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribePolicyDetailsResult::~DescribePolicyDetailsResult()
+{}
+
+void DescribePolicyDetailsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto policyNode = value["Policy"];
+	if(!policyNode["Name"].isNull())
+		policy_.name = policyNode["Name"].asString();
+	if(!policyNode["Category"].isNull())
+		policy_.category = policyNode["Category"].asString();
+	if(!policyNode["Description"].isNull())
+		policy_.description = policyNode["Description"].asString();
+	if(!policyNode["Action"].isNull())
+		policy_.action = policyNode["Action"].asString();
+	if(!policyNode["Severity"].isNull())
+		policy_.severity = policyNode["Severity"].asString();
+	if(!policyNode["Template"].isNull())
+		policy_._template = policyNode["Template"].asString();
+	if(!policyNode["NoConfig"].isNull())
+		policy_.noConfig = std::stoi(policyNode["NoConfig"].asString());
+	if(!policyNode["Created"].isNull())
+		policy_.created = policyNode["Created"].asString();
+	if(!policyNode["Updated"].isNull())
+		policy_.updated = policyNode["Updated"].asString();
+
+}
+
+DescribePolicyDetailsResult::Policy DescribePolicyDetailsResult::getPolicy()const
+{
+	return policy_;
+}
+

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

adcp/src/model/DescribePolicyGovernanceInClusterResult.cc

@@ -0,0 +1,146 @@
+/*
+ * 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/DescribePolicyGovernanceInClusterResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adcp;
+using namespace AlibabaCloud::Adcp::Model;
+
+DescribePolicyGovernanceInClusterResult::DescribePolicyGovernanceInClusterResult() :
+	ServiceResult()
+{}
+
+DescribePolicyGovernanceInClusterResult::DescribePolicyGovernanceInClusterResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribePolicyGovernanceInClusterResult::~DescribePolicyGovernanceInClusterResult()
+{}
+
+void DescribePolicyGovernanceInClusterResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allPolicyGovernancesNode = value["PolicyGovernances"]["PolicyGovernance"];
+	for (auto valuePolicyGovernancesPolicyGovernance : allPolicyGovernancesNode)
+	{
+		PolicyGovernance policyGovernancesObject;
+		auto clusterNode = value["Cluster"];
+		if(!clusterNode["ClusterId"].isNull())
+			policyGovernancesObject.cluster.clusterId = clusterNode["ClusterId"].asString();
+		if(!clusterNode["Name"].isNull())
+			policyGovernancesObject.cluster.name = clusterNode["Name"].asString();
+		if(!clusterNode["RegionId"].isNull())
+			policyGovernancesObject.cluster.regionId = clusterNode["RegionId"].asString();
+		if(!clusterNode["State"].isNull())
+			policyGovernancesObject.cluster.state = clusterNode["State"].asString();
+		if(!clusterNode["ClusterType"].isNull())
+			policyGovernancesObject.cluster.clusterType = clusterNode["ClusterType"].asString();
+		if(!clusterNode["ClusterSpec"].isNull())
+			policyGovernancesObject.cluster.clusterSpec = clusterNode["ClusterSpec"].asString();
+		if(!clusterNode["Profile"].isNull())
+			policyGovernancesObject.cluster.profile = clusterNode["Profile"].asString();
+		auto policyGovernance1Node = value["PolicyGovernance"];
+		auto allOnStateNode = policyGovernance1Node["OnState"]["State"];
+		for (auto policyGovernance1NodeOnStateState : allOnStateNode)
+		{
+			PolicyGovernance::PolicyGovernance1::State stateObject;
+			if(!policyGovernance1NodeOnStateState["EnabledCount"].isNull())
+				stateObject.enabledCount = std::stol(policyGovernance1NodeOnStateState["EnabledCount"].asString());
+			if(!policyGovernance1NodeOnStateState["TotalCount"].isNull())
+				stateObject.totalCount = std::stol(policyGovernance1NodeOnStateState["TotalCount"].asString());
+			if(!policyGovernance1NodeOnStateState["Severity"].isNull())
+				stateObject.severity = policyGovernance1NodeOnStateState["Severity"].asString();
+			policyGovernancesObject.policyGovernance1.onState.push_back(stateObject);
+		}
+		auto admitLogNode = policyGovernance1Node["AdmitLog"];
+		if(!admitLogNode["Progress"].isNull())
+			policyGovernancesObject.policyGovernance1.admitLog.progress = admitLogNode["Progress"].asString();
+		if(!admitLogNode["Count"].isNull())
+			policyGovernancesObject.policyGovernance1.admitLog.count = admitLogNode["Count"].asString();
+		if(!admitLogNode["LogProject"].isNull())
+			policyGovernancesObject.policyGovernance1.admitLog.logProject = admitLogNode["LogProject"].asString();
+		if(!admitLogNode["LogStore"].isNull())
+			policyGovernancesObject.policyGovernance1.admitLog.logStore = admitLogNode["LogStore"].asString();
+			auto allLogs = admitLogNode["Logs"]["Log"];
+			for (auto value : allLogs)
+				policyGovernancesObject.policyGovernance1.admitLog.logs.push_back(value.asString());
+		auto violationNode = policyGovernance1Node["Violation"];
+		auto totalViolationsNode = violationNode["TotalViolations"];
+		auto allDenyNode = totalViolationsNode["Deny"]["DenySeverity"];
+		for (auto totalViolationsNodeDenyDenySeverity : allDenyNode)
+		{
+			PolicyGovernance::PolicyGovernance1::Violation::TotalViolations::DenySeverity denySeverityObject;
+			if(!totalViolationsNodeDenyDenySeverity["Severity"].isNull())
+				denySeverityObject.severity = totalViolationsNodeDenyDenySeverity["Severity"].asString();
+			if(!totalViolationsNodeDenyDenySeverity["Violations"].isNull())
+				denySeverityObject.violations = std::stol(totalViolationsNodeDenyDenySeverity["Violations"].asString());
+			policyGovernancesObject.policyGovernance1.violation.totalViolations.deny.push_back(denySeverityObject);
+		}
+		auto allWarnNode = totalViolationsNode["Warn"]["WarnSeverity"];
+		for (auto totalViolationsNodeWarnWarnSeverity : allWarnNode)
+		{
+			PolicyGovernance::PolicyGovernance1::Violation::TotalViolations::WarnSeverity warnSeverityObject;
+			if(!totalViolationsNodeWarnWarnSeverity["Severity"].isNull())
+				warnSeverityObject.severity = totalViolationsNodeWarnWarnSeverity["Severity"].asString();
+			if(!totalViolationsNodeWarnWarnSeverity["Violations"].isNull())
+				warnSeverityObject.violations = totalViolationsNodeWarnWarnSeverity["Violations"].asString();
+			policyGovernancesObject.policyGovernance1.violation.totalViolations.warn.push_back(warnSeverityObject);
+		}
+		auto violationsNode = violationNode["Violations"];
+		auto allDeny2Node = violationsNode["Deny"]["DenyViolations"];
+		for (auto violationsNodeDenyDenyViolations : allDeny2Node)
+		{
+			PolicyGovernance::PolicyGovernance1::Violation::Violations::DenyViolations denyViolationsObject;
+			if(!violationsNodeDenyDenyViolations["PolicyName"].isNull())
+				denyViolationsObject.policyName = violationsNodeDenyDenyViolations["PolicyName"].asString();
+			if(!violationsNodeDenyDenyViolations["PolicyDescription"].isNull())
+				denyViolationsObject.policyDescription = violationsNodeDenyDenyViolations["PolicyDescription"].asString();
+			if(!violationsNodeDenyDenyViolations["Severity"].isNull())
+				denyViolationsObject.severity = violationsNodeDenyDenyViolations["Severity"].asString();
+			if(!violationsNodeDenyDenyViolations["Violations"].isNull())
+				denyViolationsObject.violations = std::stol(violationsNodeDenyDenyViolations["Violations"].asString());
+			policyGovernancesObject.policyGovernance1.violation.violations.deny2.push_back(denyViolationsObject);
+		}
+		auto allWarn3Node = violationsNode["Warn"]["WarnViolations"];
+		for (auto violationsNodeWarnWarnViolations : allWarn3Node)
+		{
+			PolicyGovernance::PolicyGovernance1::Violation::Violations::WarnViolations warnViolationsObject;
+			if(!violationsNodeWarnWarnViolations["PolicyName"].isNull())
+				warnViolationsObject.policyName = violationsNodeWarnWarnViolations["PolicyName"].asString();
+			if(!violationsNodeWarnWarnViolations["PolicyDescription"].isNull())
+				warnViolationsObject.policyDescription = violationsNodeWarnWarnViolations["PolicyDescription"].asString();
+			if(!violationsNodeWarnWarnViolations["Severity"].isNull())
+				warnViolationsObject.severity = violationsNodeWarnWarnViolations["Severity"].asString();
+			if(!violationsNodeWarnWarnViolations["Violations"].isNull())
+				warnViolationsObject.violations = std::stol(violationsNodeWarnWarnViolations["Violations"].asString());
+			policyGovernancesObject.policyGovernance1.violation.violations.warn3.push_back(warnViolationsObject);
+		}
+		policyGovernances_.push_back(policyGovernancesObject);
+	}
+
+}
+
+std::vector<DescribePolicyGovernanceInClusterResult::PolicyGovernance> DescribePolicyGovernanceInClusterResult::getPolicyGovernances()const
+{
+	return policyGovernances_;
+}
+

adcp/src/model/DescribePolicyInstancesRequest.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/DescribePolicyInstancesRequest.h>
+
+using AlibabaCloud::Adcp::Model::DescribePolicyInstancesRequest;
+
+DescribePolicyInstancesRequest::DescribePolicyInstancesRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "DescribePolicyInstances") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribePolicyInstancesRequest::~DescribePolicyInstancesRequest() {}
+
+std::string DescribePolicyInstancesRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DescribePolicyInstancesRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string DescribePolicyInstancesRequest::getPolicyName() const {
+  return policyName_;
+}
+
+void DescribePolicyInstancesRequest::setPolicyName(const std::string &policyName) {
+  policyName_ = policyName;
+  setParameter(std::string("PolicyName"), policyName);
+}
+

adcp/src/model/DescribePolicyInstancesResult.cc

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/adcp/model/DescribePolicyInstancesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adcp;
+using namespace AlibabaCloud::Adcp::Model;
+
+DescribePolicyInstancesResult::DescribePolicyInstancesResult() :
+	ServiceResult()
+{}
+
+DescribePolicyInstancesResult::DescribePolicyInstancesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribePolicyInstancesResult::~DescribePolicyInstancesResult()
+{}
+
+void DescribePolicyInstancesResult::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["PolicyName"].isNull())
+			policiesObject.policyName = valuePoliciesPolicy["PolicyName"].asString();
+		if(!valuePoliciesPolicy["InstanceName"].isNull())
+			policiesObject.instanceName = valuePoliciesPolicy["InstanceName"].asString();
+		if(!valuePoliciesPolicy["PolicyCategory"].isNull())
+			policiesObject.policyCategory = valuePoliciesPolicy["PolicyCategory"].asString();
+		if(!valuePoliciesPolicy["PolicyDescription"].isNull())
+			policiesObject.policyDescription = valuePoliciesPolicy["PolicyDescription"].asString();
+		if(!valuePoliciesPolicy["PolicySeverity"].isNull())
+			policiesObject.policySeverity = valuePoliciesPolicy["PolicySeverity"].asString();
+		if(!valuePoliciesPolicy["PolicyScope"].isNull())
+			policiesObject.policyScope = valuePoliciesPolicy["PolicyScope"].asString();
+		if(!valuePoliciesPolicy["PolicyAction"].isNull())
+			policiesObject.policyAction = valuePoliciesPolicy["PolicyAction"].asString();
+		if(!valuePoliciesPolicy["TotalViolations"].isNull())
+			policiesObject.totalViolations = std::stol(valuePoliciesPolicy["TotalViolations"].asString());
+		if(!valuePoliciesPolicy["ClusterId"].isNull())
+			policiesObject.clusterId = valuePoliciesPolicy["ClusterId"].asString();
+		if(!valuePoliciesPolicy["PolicyParameters"].isNull())
+			policiesObject.policyParameters = valuePoliciesPolicy["PolicyParameters"].asString();
+		policies_.push_back(policiesObject);
+	}
+
+}
+
+std::vector<DescribePolicyInstancesResult::Policy> DescribePolicyInstancesResult::getPolicies()const
+{
+	return policies_;
+}
+

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

adcp/src/model/DescribePolicyInstancesStatusResult.cc

@@ -0,0 +1,86 @@
+/*
+ * 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/DescribePolicyInstancesStatusResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adcp;
+using namespace AlibabaCloud::Adcp::Model;
+
+DescribePolicyInstancesStatusResult::DescribePolicyInstancesStatusResult() :
+	ServiceResult()
+{}
+
+DescribePolicyInstancesStatusResult::DescribePolicyInstancesStatusResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribePolicyInstancesStatusResult::~DescribePolicyInstancesStatusResult()
+{}
+
+void DescribePolicyInstancesStatusResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto policiesNode = value["Policies"];
+	auto allPolicyInstancesNode = policiesNode["PolicyInstances"]["PolicyInstance"];
+	for (auto policiesNodePolicyInstancesPolicyInstance : allPolicyInstancesNode)
+	{
+		Policies::PolicyInstance policyInstanceObject;
+		if(!policiesNodePolicyInstancesPolicyInstance["PolicyName"].isNull())
+			policyInstanceObject.policyName = policiesNodePolicyInstancesPolicyInstance["PolicyName"].asString();
+		if(!policiesNodePolicyInstancesPolicyInstance["PolicyCategory"].isNull())
+			policyInstanceObject.policyCategory = policiesNodePolicyInstancesPolicyInstance["PolicyCategory"].asString();
+		if(!policiesNodePolicyInstancesPolicyInstance["PolicyDescription"].isNull())
+			policyInstanceObject.policyDescription = policiesNodePolicyInstancesPolicyInstance["PolicyDescription"].asString();
+		if(!policiesNodePolicyInstancesPolicyInstance["PolicySeverity"].isNull())
+			policyInstanceObject.policySeverity = policiesNodePolicyInstancesPolicyInstance["PolicySeverity"].asString();
+		if(!policiesNodePolicyInstancesPolicyInstance["PolicyInstancesCount"].isNull())
+			policyInstanceObject.policyInstancesCount = std::stol(policiesNodePolicyInstancesPolicyInstance["PolicyInstancesCount"].asString());
+		auto allPolicyClustersNode = policiesNodePolicyInstancesPolicyInstance["PolicyClusters"]["PolicyCluster"];
+		for (auto policiesNodePolicyInstancesPolicyInstancePolicyClustersPolicyCluster : allPolicyClustersNode)
+		{
+			Policies::PolicyInstance::PolicyCluster policyClustersObject;
+			if(!policiesNodePolicyInstancesPolicyInstancePolicyClustersPolicyCluster["ClusterId"].isNull())
+				policyClustersObject.clusterId = policiesNodePolicyInstancesPolicyInstancePolicyClustersPolicyCluster["ClusterId"].asString();
+			if(!policiesNodePolicyInstancesPolicyInstancePolicyClustersPolicyCluster["Status"].isNull())
+				policyClustersObject.status = policiesNodePolicyInstancesPolicyInstancePolicyClustersPolicyCluster["Status"].asString();
+			policyInstanceObject.policyClusters.push_back(policyClustersObject);
+		}
+		policies_.policyInstances.push_back(policyInstanceObject);
+	}
+	auto allSeverityInfoNode = policiesNode["SeverityInfo"]["SeverityInfoItem"];
+	for (auto policiesNodeSeverityInfoSeverityInfoItem : allSeverityInfoNode)
+	{
+		Policies::SeverityInfoItem severityInfoItemObject;
+		if(!policiesNodeSeverityInfoSeverityInfoItem["SeverityType"].isNull())
+			severityInfoItemObject.severityType = policiesNodeSeverityInfoSeverityInfoItem["SeverityType"].asString();
+		if(!policiesNodeSeverityInfoSeverityInfoItem["SeverityCount"].isNull())
+			severityInfoItemObject.severityCount = policiesNodeSeverityInfoSeverityInfoItem["SeverityCount"].asString();
+		policies_.severityInfo.push_back(severityInfoItemObject);
+	}
+
+}
+
+DescribePolicyInstancesStatusResult::Policies DescribePolicyInstancesStatusResult::getPolicies()const
+{
+	return policies_;
+}
+

adcp/src/model/DescribeRegionsRequest.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/DescribeRegionsRequest.h>
+
+using AlibabaCloud::Adcp::Model::DescribeRegionsRequest;
+
+DescribeRegionsRequest::DescribeRegionsRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "DescribeRegions") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeRegionsRequest::~DescribeRegionsRequest() {}
+
+std::string DescribeRegionsRequest::getLanguage() const {
+  return language_;
+}
+
+void DescribeRegionsRequest::setLanguage(const std::string &language) {
+  language_ = language;
+  setParameter(std::string("Language"), language);
+}
+

adcp/src/model/DescribeRegionsResult.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/DescribeRegionsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adcp;
+using namespace AlibabaCloud::Adcp::Model;
+
+DescribeRegionsResult::DescribeRegionsResult() :
+	ServiceResult()
+{}
+
+DescribeRegionsResult::DescribeRegionsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeRegionsResult::~DescribeRegionsResult()
+{}
+
+void DescribeRegionsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRegionsNode = value["Regions"]["Region"];
+	for (auto valueRegionsRegion : allRegionsNode)
+	{
+		Region regionsObject;
+		if(!valueRegionsRegion["RegionId"].isNull())
+			regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
+		if(!valueRegionsRegion["RegionEndpoint"].isNull())
+			regionsObject.regionEndpoint = valueRegionsRegion["RegionEndpoint"].asString();
+		if(!valueRegionsRegion["RegionVpcEndpoint"].isNull())
+			regionsObject.regionVpcEndpoint = valueRegionsRegion["RegionVpcEndpoint"].asString();
+		if(!valueRegionsRegion["LocalName"].isNull())
+			regionsObject.localName = valueRegionsRegion["LocalName"].asString();
+		regions_.push_back(regionsObject);
+	}
+
+}
+
+std::vector<DescribeRegionsResult::Region> DescribeRegionsResult::getRegions()const
+{
+	return regions_;
+}
+

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

adcp/src/model/DescribeUserPermissionsResult.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/DescribeUserPermissionsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adcp;
+using namespace AlibabaCloud::Adcp::Model;
+
+DescribeUserPermissionsResult::DescribeUserPermissionsResult() :
+	ServiceResult()
+{}
+
+DescribeUserPermissionsResult::DescribeUserPermissionsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeUserPermissionsResult::~DescribeUserPermissionsResult()
+{}
+
+void DescribeUserPermissionsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allPermissionsNode = value["Permissions"]["Permission"];
+	for (auto valuePermissionsPermission : allPermissionsNode)
+	{
+		Permission permissionsObject;
+		if(!valuePermissionsPermission["RoleType"].isNull())
+			permissionsObject.roleType = valuePermissionsPermission["RoleType"].asString();
+		if(!valuePermissionsPermission["RoleName"].isNull())
+			permissionsObject.roleName = valuePermissionsPermission["RoleName"].asString();
+		if(!valuePermissionsPermission["ResourceType"].isNull())
+			permissionsObject.resourceType = valuePermissionsPermission["ResourceType"].asString();
+		if(!valuePermissionsPermission["ResourceId"].isNull())
+			permissionsObject.resourceId = valuePermissionsPermission["ResourceId"].asString();
+		permissions_.push_back(permissionsObject);
+	}
+
+}
+
+std::vector<DescribeUserPermissionsResult::Permission> DescribeUserPermissionsResult::getPermissions()const
+{
+	return permissions_;
+}
+

adcp/src/model/DetachClusterFromHubRequest.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/DetachClusterFromHubRequest.h>
+
+using AlibabaCloud::Adcp::Model::DetachClusterFromHubRequest;
+
+DetachClusterFromHubRequest::DetachClusterFromHubRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "DetachClusterFromHub") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DetachClusterFromHubRequest::~DetachClusterFromHubRequest() {}
+
+bool DetachClusterFromHubRequest::getDetachFromMesh() const {
+  return detachFromMesh_;
+}
+
+void DetachClusterFromHubRequest::setDetachFromMesh(bool detachFromMesh) {
+  detachFromMesh_ = detachFromMesh;
+  setParameter(std::string("DetachFromMesh"), detachFromMesh ? "true" : "false");
+}
+
+std::string DetachClusterFromHubRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DetachClusterFromHubRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string DetachClusterFromHubRequest::getClusterIds() const {
+  return clusterIds_;
+}
+
+void DetachClusterFromHubRequest::setClusterIds(const std::string &clusterIds) {
+  clusterIds_ = clusterIds;
+  setBodyParameter(std::string("ClusterIds"), clusterIds);
+}
+

adcp/src/model/DetachClusterFromHubResult.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/DetachClusterFromHubResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adcp;
+using namespace AlibabaCloud::Adcp::Model;
+
+DetachClusterFromHubResult::DetachClusterFromHubResult() :
+	ServiceResult()
+{}
+
+DetachClusterFromHubResult::DetachClusterFromHubResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetachClusterFromHubResult::~DetachClusterFromHubResult()
+{}
+
+void DetachClusterFromHubResult::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 DetachClusterFromHubResult::getTaskId()const
+{
+	return taskId_;
+}
+
+std::string DetachClusterFromHubResult::getClusterId()const
+{
+	return clusterId_;
+}
+
+std::vector<std::string> DetachClusterFromHubResult::getManagedClusterIds()const
+{
+	return managedClusterIds_;
+}
+

adcp/src/model/GrantUserPermissionRequest.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/adcp/model/GrantUserPermissionRequest.h>
+
+using AlibabaCloud::Adcp::Model::GrantUserPermissionRequest;
+
+GrantUserPermissionRequest::GrantUserPermissionRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "GrantUserPermission") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GrantUserPermissionRequest::~GrantUserPermissionRequest() {}
+
+std::string GrantUserPermissionRequest::getUserId() const {
+  return userId_;
+}
+
+void GrantUserPermissionRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+bool GrantUserPermissionRequest::getIsRamRole() const {
+  return isRamRole_;
+}
+
+void GrantUserPermissionRequest::setIsRamRole(bool isRamRole) {
+  isRamRole_ = isRamRole;
+  setParameter(std::string("IsRamRole"), isRamRole ? "true" : "false");
+}
+
+std::string GrantUserPermissionRequest::getRoleType() const {
+  return roleType_;
+}
+
+void GrantUserPermissionRequest::setRoleType(const std::string &roleType) {
+  roleType_ = roleType;
+  setParameter(std::string("RoleType"), roleType);
+}
+
+std::string GrantUserPermissionRequest::getRoleName() const {
+  return roleName_;
+}
+
+void GrantUserPermissionRequest::setRoleName(const std::string &roleName) {
+  roleName_ = roleName;
+  setParameter(std::string("RoleName"), roleName);
+}
+
+std::string GrantUserPermissionRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void GrantUserPermissionRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string GrantUserPermissionRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void GrantUserPermissionRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setParameter(std::string("Namespace"), _namespace);
+}
+

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

adcp/src/model/GrantUserPermissionsRequest.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/GrantUserPermissionsRequest.h>
+
+using AlibabaCloud::Adcp::Model::GrantUserPermissionsRequest;
+
+GrantUserPermissionsRequest::GrantUserPermissionsRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "GrantUserPermissions") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GrantUserPermissionsRequest::~GrantUserPermissionsRequest() {}
+
+std::string GrantUserPermissionsRequest::getUserId() const {
+  return userId_;
+}
+
+void GrantUserPermissionsRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::vector<GrantUserPermissionsRequest::Permissions> GrantUserPermissionsRequest::getPermissions() const {
+  return permissions_;
+}
+
+void GrantUserPermissionsRequest::setPermissions(const std::vector<GrantUserPermissionsRequest::Permissions> &permissions) {
+  permissions_ = permissions;
+  for(int dep1 = 0; dep1 != permissions.size(); dep1++) {
+    setParameter(std::string("Permissions") + "." + std::to_string(dep1 + 1) + ".IsRamRole", permissions[dep1].isRamRole ? "true" : "false");
+    setParameter(std::string("Permissions") + "." + std::to_string(dep1 + 1) + ".RoleName", permissions[dep1].roleName);
+    setParameter(std::string("Permissions") + "." + std::to_string(dep1 + 1) + ".Namespace", permissions[dep1]._namespace);
+    setParameter(std::string("Permissions") + "." + std::to_string(dep1 + 1) + ".RoleType", permissions[dep1].roleType);
+    setParameter(std::string("Permissions") + "." + std::to_string(dep1 + 1) + ".ClusterId", permissions[dep1].clusterId);
+  }
+}
+

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

adcp/src/model/UpdateHubClusterFeatureRequest.cc

@@ -0,0 +1,175 @@
+/*
+ * 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/UpdateHubClusterFeatureRequest.h>
+
+using AlibabaCloud::Adcp::Model::UpdateHubClusterFeatureRequest;
+
+UpdateHubClusterFeatureRequest::UpdateHubClusterFeatureRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "UpdateHubClusterFeature") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateHubClusterFeatureRequest::~UpdateHubClusterFeatureRequest() {}
+
+std::vector<UpdateHubClusterFeatureRequest::std::string> UpdateHubClusterFeatureRequest::getAccessControlList() const {
+  return accessControlList_;
+}
+
+void UpdateHubClusterFeatureRequest::setAccessControlList(const std::vector<UpdateHubClusterFeatureRequest::std::string> &accessControlList) {
+  accessControlList_ = accessControlList;
+  for(int dep1 = 0; dep1 != accessControlList.size(); dep1++) {
+    setParameter(std::string("AccessControlList") + "." + std::to_string(dep1 + 1), accessControlList[dep1]);
+  }
+}
+
+bool UpdateHubClusterFeatureRequest::getMonitorEnabled() const {
+  return monitorEnabled_;
+}
+
+void UpdateHubClusterFeatureRequest::setMonitorEnabled(bool monitorEnabled) {
+  monitorEnabled_ = monitorEnabled;
+  setParameter(std::string("MonitorEnabled"), monitorEnabled ? "true" : "false");
+}
+
+bool UpdateHubClusterFeatureRequest::getDeletionProtection() const {
+  return deletionProtection_;
+}
+
+void UpdateHubClusterFeatureRequest::setDeletionProtection(bool deletionProtection) {
+  deletionProtection_ = deletionProtection;
+  setParameter(std::string("DeletionProtection"), deletionProtection ? "true" : "false");
+}
+
+bool UpdateHubClusterFeatureRequest::getEnableMesh() const {
+  return enableMesh_;
+}
+
+void UpdateHubClusterFeatureRequest::setEnableMesh(bool enableMesh) {
+  enableMesh_ = enableMesh;
+  setParameter(std::string("EnableMesh"), enableMesh ? "true" : "false");
+}
+
+bool UpdateHubClusterFeatureRequest::getArgoCDHAEnabled() const {
+  return argoCDHAEnabled_;
+}
+
+void UpdateHubClusterFeatureRequest::setArgoCDHAEnabled(bool argoCDHAEnabled) {
+  argoCDHAEnabled_ = argoCDHAEnabled;
+  setParameter(std::string("ArgoCDHAEnabled"), argoCDHAEnabled ? "true" : "false");
+}
+
+bool UpdateHubClusterFeatureRequest::getArgoCDEnabled() const {
+  return argoCDEnabled_;
+}
+
+void UpdateHubClusterFeatureRequest::setArgoCDEnabled(bool argoCDEnabled) {
+  argoCDEnabled_ = argoCDEnabled;
+  setParameter(std::string("ArgoCDEnabled"), argoCDEnabled ? "true" : "false");
+}
+
+std::vector<UpdateHubClusterFeatureRequest::std::string> UpdateHubClusterFeatureRequest::getVSwitches() const {
+  return vSwitches_;
+}
+
+void UpdateHubClusterFeatureRequest::setVSwitches(const std::vector<UpdateHubClusterFeatureRequest::std::string> &vSwitches) {
+  vSwitches_ = vSwitches;
+  for(int dep1 = 0; dep1 != vSwitches.size(); dep1++) {
+    setParameter(std::string("VSwitches") + "." + std::to_string(dep1 + 1), vSwitches[dep1]);
+  }
+}
+
+std::string UpdateHubClusterFeatureRequest::getName() const {
+  return name_;
+}
+
+void UpdateHubClusterFeatureRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+bool UpdateHubClusterFeatureRequest::getPublicAccessEnabled() const {
+  return publicAccessEnabled_;
+}
+
+void UpdateHubClusterFeatureRequest::setPublicAccessEnabled(bool publicAccessEnabled) {
+  publicAccessEnabled_ = publicAccessEnabled;
+  setParameter(std::string("PublicAccessEnabled"), publicAccessEnabled ? "true" : "false");
+}
+
+bool UpdateHubClusterFeatureRequest::getPublicApiServerEnabled() const {
+  return publicApiServerEnabled_;
+}
+
+void UpdateHubClusterFeatureRequest::setPublicApiServerEnabled(bool publicApiServerEnabled) {
+  publicApiServerEnabled_ = publicApiServerEnabled;
+  setParameter(std::string("PublicApiServerEnabled"), publicApiServerEnabled ? "true" : "false");
+}
+
+bool UpdateHubClusterFeatureRequest::getArgoServerEnabled() const {
+  return argoServerEnabled_;
+}
+
+void UpdateHubClusterFeatureRequest::setArgoServerEnabled(bool argoServerEnabled) {
+  argoServerEnabled_ = argoServerEnabled;
+  setParameter(std::string("ArgoServerEnabled"), argoServerEnabled ? "true" : "false");
+}
+
+std::string UpdateHubClusterFeatureRequest::getWorkflowScheduleMode() const {
+  return workflowScheduleMode_;
+}
+
+void UpdateHubClusterFeatureRequest::setWorkflowScheduleMode(const std::string &workflowScheduleMode) {
+  workflowScheduleMode_ = workflowScheduleMode;
+  setParameter(std::string("WorkflowScheduleMode"), workflowScheduleMode);
+}
+
+bool UpdateHubClusterFeatureRequest::getAuditLogEnabled() const {
+  return auditLogEnabled_;
+}
+
+void UpdateHubClusterFeatureRequest::setAuditLogEnabled(bool auditLogEnabled) {
+  auditLogEnabled_ = auditLogEnabled;
+  setParameter(std::string("AuditLogEnabled"), auditLogEnabled ? "true" : "false");
+}
+
+std::string UpdateHubClusterFeatureRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void UpdateHubClusterFeatureRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string UpdateHubClusterFeatureRequest::getPriceLimit() const {
+  return priceLimit_;
+}
+
+void UpdateHubClusterFeatureRequest::setPriceLimit(const std::string &priceLimit) {
+  priceLimit_ = priceLimit;
+  setParameter(std::string("PriceLimit"), priceLimit);
+}
+
+std::string UpdateHubClusterFeatureRequest::getApiServerEipId() const {
+  return apiServerEipId_;
+}
+
+void UpdateHubClusterFeatureRequest::setApiServerEipId(const std::string &apiServerEipId) {
+  apiServerEipId_ = apiServerEipId;
+  setParameter(std::string("ApiServerEipId"), apiServerEipId);
+}
+

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

adcp/src/model/UpdateUserPermissionRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/adcp/model/UpdateUserPermissionRequest.h>
+
+using AlibabaCloud::Adcp::Model::UpdateUserPermissionRequest;
+
+UpdateUserPermissionRequest::UpdateUserPermissionRequest()
+    : RpcServiceRequest("adcp", "2022-01-01", "UpdateUserPermission") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateUserPermissionRequest::~UpdateUserPermissionRequest() {}
+
+std::string UpdateUserPermissionRequest::getUserId() const {
+  return userId_;
+}
+
+void UpdateUserPermissionRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string UpdateUserPermissionRequest::getRoleType() const {
+  return roleType_;
+}
+
+void UpdateUserPermissionRequest::setRoleType(const std::string &roleType) {
+  roleType_ = roleType;
+  setParameter(std::string("RoleType"), roleType);
+}
+
+std::string UpdateUserPermissionRequest::getRoleName() const {
+  return roleName_;
+}
+
+void UpdateUserPermissionRequest::setRoleName(const std::string &roleName) {
+  roleName_ = roleName;
+  setParameter(std::string("RoleName"), roleName);
+}
+
+std::string UpdateUserPermissionRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void UpdateUserPermissionRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string UpdateUserPermissionRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void UpdateUserPermissionRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setParameter(std::string("Namespace"), _namespace);
+}
+

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