Generated 2020-01-11 for servicemesh.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-12-17 Version: patch
+- Generated 2020-01-11 for `servicemesh`.
+
 2020-12-17 Version: patch
 - Update api.
 

servicemesh/CMakeLists.txt

@@ -0,0 +1,190 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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(servicemesh_public_header 
+	include/alibabacloud/servicemesh/ServicemeshClient.h
+	include/alibabacloud/servicemesh/ServicemeshExport.h )
+
+set(servicemesh_public_header_model 
+	include/alibabacloud/servicemesh/model/AddClusterIntoServiceMeshRequest.h
+	include/alibabacloud/servicemesh/model/AddClusterIntoServiceMeshResult.h
+	include/alibabacloud/servicemesh/model/AddVmAppToMeshRequest.h
+	include/alibabacloud/servicemesh/model/AddVmAppToMeshResult.h
+	include/alibabacloud/servicemesh/model/CreateServiceMeshRequest.h
+	include/alibabacloud/servicemesh/model/CreateServiceMeshResult.h
+	include/alibabacloud/servicemesh/model/DeleteServiceMeshRequest.h
+	include/alibabacloud/servicemesh/model/DeleteServiceMeshResult.h
+	include/alibabacloud/servicemesh/model/DescribeCensRequest.h
+	include/alibabacloud/servicemesh/model/DescribeCensResult.h
+	include/alibabacloud/servicemesh/model/DescribeClusterGrafanaRequest.h
+	include/alibabacloud/servicemesh/model/DescribeClusterGrafanaResult.h
+	include/alibabacloud/servicemesh/model/DescribeClusterPrometheusRequest.h
+	include/alibabacloud/servicemesh/model/DescribeClusterPrometheusResult.h
+	include/alibabacloud/servicemesh/model/DescribeClustersInServiceMeshRequest.h
+	include/alibabacloud/servicemesh/model/DescribeClustersInServiceMeshResult.h
+	include/alibabacloud/servicemesh/model/DescribeGuestClusterAccessLogDashboardsRequest.h
+	include/alibabacloud/servicemesh/model/DescribeGuestClusterAccessLogDashboardsResult.h
+	include/alibabacloud/servicemesh/model/DescribeIngressGatewaysRequest.h
+	include/alibabacloud/servicemesh/model/DescribeIngressGatewaysResult.h
+	include/alibabacloud/servicemesh/model/DescribeServiceMeshDetailRequest.h
+	include/alibabacloud/servicemesh/model/DescribeServiceMeshDetailResult.h
+	include/alibabacloud/servicemesh/model/DescribeServiceMeshKubeconfigRequest.h
+	include/alibabacloud/servicemesh/model/DescribeServiceMeshKubeconfigResult.h
+	include/alibabacloud/servicemesh/model/DescribeServiceMeshesRequest.h
+	include/alibabacloud/servicemesh/model/DescribeServiceMeshesResult.h
+	include/alibabacloud/servicemesh/model/DescribeUpgradeVersionRequest.h
+	include/alibabacloud/servicemesh/model/DescribeUpgradeVersionResult.h
+	include/alibabacloud/servicemesh/model/GetDiagnosisRequest.h
+	include/alibabacloud/servicemesh/model/GetDiagnosisResult.h
+	include/alibabacloud/servicemesh/model/GetRegisteredServiceEndpointsRequest.h
+	include/alibabacloud/servicemesh/model/GetRegisteredServiceEndpointsResult.h
+	include/alibabacloud/servicemesh/model/GetRegisteredServiceNamespacesRequest.h
+	include/alibabacloud/servicemesh/model/GetRegisteredServiceNamespacesResult.h
+	include/alibabacloud/servicemesh/model/GetRegisteredServicesRequest.h
+	include/alibabacloud/servicemesh/model/GetRegisteredServicesResult.h
+	include/alibabacloud/servicemesh/model/GetServiceMeshSlbRequest.h
+	include/alibabacloud/servicemesh/model/GetServiceMeshSlbResult.h
+	include/alibabacloud/servicemesh/model/GetVmAppMeshInfoRequest.h
+	include/alibabacloud/servicemesh/model/GetVmAppMeshInfoResult.h
+	include/alibabacloud/servicemesh/model/GetVmMetaRequest.h
+	include/alibabacloud/servicemesh/model/GetVmMetaResult.h
+	include/alibabacloud/servicemesh/model/RemoveClusterFromServiceMeshRequest.h
+	include/alibabacloud/servicemesh/model/RemoveClusterFromServiceMeshResult.h
+	include/alibabacloud/servicemesh/model/RemoveVmAppFromMeshRequest.h
+	include/alibabacloud/servicemesh/model/RemoveVmAppFromMeshResult.h
+	include/alibabacloud/servicemesh/model/RunDiagnosisRequest.h
+	include/alibabacloud/servicemesh/model/RunDiagnosisResult.h
+	include/alibabacloud/servicemesh/model/UpdateIstioInjectionConfigRequest.h
+	include/alibabacloud/servicemesh/model/UpdateIstioInjectionConfigResult.h
+	include/alibabacloud/servicemesh/model/UpdateMeshFeatureRequest.h
+	include/alibabacloud/servicemesh/model/UpdateMeshFeatureResult.h
+	include/alibabacloud/servicemesh/model/UpgradeMeshVersionRequest.h
+	include/alibabacloud/servicemesh/model/UpgradeMeshVersionResult.h )
+
+set(servicemesh_src 
+	src/ServicemeshClient.cc
+	src/model/AddClusterIntoServiceMeshRequest.cc
+	src/model/AddClusterIntoServiceMeshResult.cc
+	src/model/AddVmAppToMeshRequest.cc
+	src/model/AddVmAppToMeshResult.cc
+	src/model/CreateServiceMeshRequest.cc
+	src/model/CreateServiceMeshResult.cc
+	src/model/DeleteServiceMeshRequest.cc
+	src/model/DeleteServiceMeshResult.cc
+	src/model/DescribeCensRequest.cc
+	src/model/DescribeCensResult.cc
+	src/model/DescribeClusterGrafanaRequest.cc
+	src/model/DescribeClusterGrafanaResult.cc
+	src/model/DescribeClusterPrometheusRequest.cc
+	src/model/DescribeClusterPrometheusResult.cc
+	src/model/DescribeClustersInServiceMeshRequest.cc
+	src/model/DescribeClustersInServiceMeshResult.cc
+	src/model/DescribeGuestClusterAccessLogDashboardsRequest.cc
+	src/model/DescribeGuestClusterAccessLogDashboardsResult.cc
+	src/model/DescribeIngressGatewaysRequest.cc
+	src/model/DescribeIngressGatewaysResult.cc
+	src/model/DescribeServiceMeshDetailRequest.cc
+	src/model/DescribeServiceMeshDetailResult.cc
+	src/model/DescribeServiceMeshKubeconfigRequest.cc
+	src/model/DescribeServiceMeshKubeconfigResult.cc
+	src/model/DescribeServiceMeshesRequest.cc
+	src/model/DescribeServiceMeshesResult.cc
+	src/model/DescribeUpgradeVersionRequest.cc
+	src/model/DescribeUpgradeVersionResult.cc
+	src/model/GetDiagnosisRequest.cc
+	src/model/GetDiagnosisResult.cc
+	src/model/GetRegisteredServiceEndpointsRequest.cc
+	src/model/GetRegisteredServiceEndpointsResult.cc
+	src/model/GetRegisteredServiceNamespacesRequest.cc
+	src/model/GetRegisteredServiceNamespacesResult.cc
+	src/model/GetRegisteredServicesRequest.cc
+	src/model/GetRegisteredServicesResult.cc
+	src/model/GetServiceMeshSlbRequest.cc
+	src/model/GetServiceMeshSlbResult.cc
+	src/model/GetVmAppMeshInfoRequest.cc
+	src/model/GetVmAppMeshInfoResult.cc
+	src/model/GetVmMetaRequest.cc
+	src/model/GetVmMetaResult.cc
+	src/model/RemoveClusterFromServiceMeshRequest.cc
+	src/model/RemoveClusterFromServiceMeshResult.cc
+	src/model/RemoveVmAppFromMeshRequest.cc
+	src/model/RemoveVmAppFromMeshResult.cc
+	src/model/RunDiagnosisRequest.cc
+	src/model/RunDiagnosisResult.cc
+	src/model/UpdateIstioInjectionConfigRequest.cc
+	src/model/UpdateIstioInjectionConfigResult.cc
+	src/model/UpdateMeshFeatureRequest.cc
+	src/model/UpdateMeshFeatureResult.cc
+	src/model/UpgradeMeshVersionRequest.cc
+	src/model/UpgradeMeshVersionResult.cc )
+
+add_library(servicemesh ${LIB_TYPE}
+	${servicemesh_public_header}
+	${servicemesh_public_header_model}
+	${servicemesh_src})
+
+set_target_properties(servicemesh
+	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}servicemesh
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(servicemesh
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_SERVICEMESH_LIBRARY)
+endif()
+
+target_include_directories(servicemesh
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(servicemesh
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(servicemesh
+		jsoncpp)
+	target_include_directories(servicemesh
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(servicemesh
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(servicemesh
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(servicemesh
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(servicemesh
+		jsoncpp)
+endif()
+
+install(FILES ${servicemesh_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/servicemesh)
+install(FILES ${servicemesh_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/servicemesh/model)
+install(TARGETS servicemesh
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

servicemesh/include/alibabacloud/servicemesh/ServicemeshClient.h

@@ -0,0 +1,262 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SERVICEMESH_SERVICEMESHCLIENT_H_
+#define ALIBABACLOUD_SERVICEMESH_SERVICEMESHCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "ServicemeshExport.h"
+#include "model/AddClusterIntoServiceMeshRequest.h"
+#include "model/AddClusterIntoServiceMeshResult.h"
+#include "model/AddVmAppToMeshRequest.h"
+#include "model/AddVmAppToMeshResult.h"
+#include "model/CreateServiceMeshRequest.h"
+#include "model/CreateServiceMeshResult.h"
+#include "model/DeleteServiceMeshRequest.h"
+#include "model/DeleteServiceMeshResult.h"
+#include "model/DescribeCensRequest.h"
+#include "model/DescribeCensResult.h"
+#include "model/DescribeClusterGrafanaRequest.h"
+#include "model/DescribeClusterGrafanaResult.h"
+#include "model/DescribeClusterPrometheusRequest.h"
+#include "model/DescribeClusterPrometheusResult.h"
+#include "model/DescribeClustersInServiceMeshRequest.h"
+#include "model/DescribeClustersInServiceMeshResult.h"
+#include "model/DescribeGuestClusterAccessLogDashboardsRequest.h"
+#include "model/DescribeGuestClusterAccessLogDashboardsResult.h"
+#include "model/DescribeIngressGatewaysRequest.h"
+#include "model/DescribeIngressGatewaysResult.h"
+#include "model/DescribeServiceMeshDetailRequest.h"
+#include "model/DescribeServiceMeshDetailResult.h"
+#include "model/DescribeServiceMeshKubeconfigRequest.h"
+#include "model/DescribeServiceMeshKubeconfigResult.h"
+#include "model/DescribeServiceMeshesRequest.h"
+#include "model/DescribeServiceMeshesResult.h"
+#include "model/DescribeUpgradeVersionRequest.h"
+#include "model/DescribeUpgradeVersionResult.h"
+#include "model/GetDiagnosisRequest.h"
+#include "model/GetDiagnosisResult.h"
+#include "model/GetRegisteredServiceEndpointsRequest.h"
+#include "model/GetRegisteredServiceEndpointsResult.h"
+#include "model/GetRegisteredServiceNamespacesRequest.h"
+#include "model/GetRegisteredServiceNamespacesResult.h"
+#include "model/GetRegisteredServicesRequest.h"
+#include "model/GetRegisteredServicesResult.h"
+#include "model/GetServiceMeshSlbRequest.h"
+#include "model/GetServiceMeshSlbResult.h"
+#include "model/GetVmAppMeshInfoRequest.h"
+#include "model/GetVmAppMeshInfoResult.h"
+#include "model/GetVmMetaRequest.h"
+#include "model/GetVmMetaResult.h"
+#include "model/RemoveClusterFromServiceMeshRequest.h"
+#include "model/RemoveClusterFromServiceMeshResult.h"
+#include "model/RemoveVmAppFromMeshRequest.h"
+#include "model/RemoveVmAppFromMeshResult.h"
+#include "model/RunDiagnosisRequest.h"
+#include "model/RunDiagnosisResult.h"
+#include "model/UpdateIstioInjectionConfigRequest.h"
+#include "model/UpdateIstioInjectionConfigResult.h"
+#include "model/UpdateMeshFeatureRequest.h"
+#include "model/UpdateMeshFeatureResult.h"
+#include "model/UpgradeMeshVersionRequest.h"
+#include "model/UpgradeMeshVersionResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		class ALIBABACLOUD_SERVICEMESH_EXPORT ServicemeshClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::AddClusterIntoServiceMeshResult> AddClusterIntoServiceMeshOutcome;
+			typedef std::future<AddClusterIntoServiceMeshOutcome> AddClusterIntoServiceMeshOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::AddClusterIntoServiceMeshRequest&, const AddClusterIntoServiceMeshOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddClusterIntoServiceMeshAsyncHandler;
+			typedef Outcome<Error, Model::AddVmAppToMeshResult> AddVmAppToMeshOutcome;
+			typedef std::future<AddVmAppToMeshOutcome> AddVmAppToMeshOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::AddVmAppToMeshRequest&, const AddVmAppToMeshOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddVmAppToMeshAsyncHandler;
+			typedef Outcome<Error, Model::CreateServiceMeshResult> CreateServiceMeshOutcome;
+			typedef std::future<CreateServiceMeshOutcome> CreateServiceMeshOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::CreateServiceMeshRequest&, const CreateServiceMeshOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateServiceMeshAsyncHandler;
+			typedef Outcome<Error, Model::DeleteServiceMeshResult> DeleteServiceMeshOutcome;
+			typedef std::future<DeleteServiceMeshOutcome> DeleteServiceMeshOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::DeleteServiceMeshRequest&, const DeleteServiceMeshOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteServiceMeshAsyncHandler;
+			typedef Outcome<Error, Model::DescribeCensResult> DescribeCensOutcome;
+			typedef std::future<DescribeCensOutcome> DescribeCensOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::DescribeCensRequest&, const DescribeCensOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCensAsyncHandler;
+			typedef Outcome<Error, Model::DescribeClusterGrafanaResult> DescribeClusterGrafanaOutcome;
+			typedef std::future<DescribeClusterGrafanaOutcome> DescribeClusterGrafanaOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::DescribeClusterGrafanaRequest&, const DescribeClusterGrafanaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeClusterGrafanaAsyncHandler;
+			typedef Outcome<Error, Model::DescribeClusterPrometheusResult> DescribeClusterPrometheusOutcome;
+			typedef std::future<DescribeClusterPrometheusOutcome> DescribeClusterPrometheusOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::DescribeClusterPrometheusRequest&, const DescribeClusterPrometheusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeClusterPrometheusAsyncHandler;
+			typedef Outcome<Error, Model::DescribeClustersInServiceMeshResult> DescribeClustersInServiceMeshOutcome;
+			typedef std::future<DescribeClustersInServiceMeshOutcome> DescribeClustersInServiceMeshOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::DescribeClustersInServiceMeshRequest&, const DescribeClustersInServiceMeshOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeClustersInServiceMeshAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGuestClusterAccessLogDashboardsResult> DescribeGuestClusterAccessLogDashboardsOutcome;
+			typedef std::future<DescribeGuestClusterAccessLogDashboardsOutcome> DescribeGuestClusterAccessLogDashboardsOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::DescribeGuestClusterAccessLogDashboardsRequest&, const DescribeGuestClusterAccessLogDashboardsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGuestClusterAccessLogDashboardsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeIngressGatewaysResult> DescribeIngressGatewaysOutcome;
+			typedef std::future<DescribeIngressGatewaysOutcome> DescribeIngressGatewaysOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::DescribeIngressGatewaysRequest&, const DescribeIngressGatewaysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeIngressGatewaysAsyncHandler;
+			typedef Outcome<Error, Model::DescribeServiceMeshDetailResult> DescribeServiceMeshDetailOutcome;
+			typedef std::future<DescribeServiceMeshDetailOutcome> DescribeServiceMeshDetailOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::DescribeServiceMeshDetailRequest&, const DescribeServiceMeshDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeServiceMeshDetailAsyncHandler;
+			typedef Outcome<Error, Model::DescribeServiceMeshKubeconfigResult> DescribeServiceMeshKubeconfigOutcome;
+			typedef std::future<DescribeServiceMeshKubeconfigOutcome> DescribeServiceMeshKubeconfigOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::DescribeServiceMeshKubeconfigRequest&, const DescribeServiceMeshKubeconfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeServiceMeshKubeconfigAsyncHandler;
+			typedef Outcome<Error, Model::DescribeServiceMeshesResult> DescribeServiceMeshesOutcome;
+			typedef std::future<DescribeServiceMeshesOutcome> DescribeServiceMeshesOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::DescribeServiceMeshesRequest&, const DescribeServiceMeshesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeServiceMeshesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeUpgradeVersionResult> DescribeUpgradeVersionOutcome;
+			typedef std::future<DescribeUpgradeVersionOutcome> DescribeUpgradeVersionOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::DescribeUpgradeVersionRequest&, const DescribeUpgradeVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUpgradeVersionAsyncHandler;
+			typedef Outcome<Error, Model::GetDiagnosisResult> GetDiagnosisOutcome;
+			typedef std::future<GetDiagnosisOutcome> GetDiagnosisOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::GetDiagnosisRequest&, const GetDiagnosisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDiagnosisAsyncHandler;
+			typedef Outcome<Error, Model::GetRegisteredServiceEndpointsResult> GetRegisteredServiceEndpointsOutcome;
+			typedef std::future<GetRegisteredServiceEndpointsOutcome> GetRegisteredServiceEndpointsOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::GetRegisteredServiceEndpointsRequest&, const GetRegisteredServiceEndpointsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetRegisteredServiceEndpointsAsyncHandler;
+			typedef Outcome<Error, Model::GetRegisteredServiceNamespacesResult> GetRegisteredServiceNamespacesOutcome;
+			typedef std::future<GetRegisteredServiceNamespacesOutcome> GetRegisteredServiceNamespacesOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::GetRegisteredServiceNamespacesRequest&, const GetRegisteredServiceNamespacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetRegisteredServiceNamespacesAsyncHandler;
+			typedef Outcome<Error, Model::GetRegisteredServicesResult> GetRegisteredServicesOutcome;
+			typedef std::future<GetRegisteredServicesOutcome> GetRegisteredServicesOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::GetRegisteredServicesRequest&, const GetRegisteredServicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetRegisteredServicesAsyncHandler;
+			typedef Outcome<Error, Model::GetServiceMeshSlbResult> GetServiceMeshSlbOutcome;
+			typedef std::future<GetServiceMeshSlbOutcome> GetServiceMeshSlbOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::GetServiceMeshSlbRequest&, const GetServiceMeshSlbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetServiceMeshSlbAsyncHandler;
+			typedef Outcome<Error, Model::GetVmAppMeshInfoResult> GetVmAppMeshInfoOutcome;
+			typedef std::future<GetVmAppMeshInfoOutcome> GetVmAppMeshInfoOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::GetVmAppMeshInfoRequest&, const GetVmAppMeshInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVmAppMeshInfoAsyncHandler;
+			typedef Outcome<Error, Model::GetVmMetaResult> GetVmMetaOutcome;
+			typedef std::future<GetVmMetaOutcome> GetVmMetaOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::GetVmMetaRequest&, const GetVmMetaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVmMetaAsyncHandler;
+			typedef Outcome<Error, Model::RemoveClusterFromServiceMeshResult> RemoveClusterFromServiceMeshOutcome;
+			typedef std::future<RemoveClusterFromServiceMeshOutcome> RemoveClusterFromServiceMeshOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::RemoveClusterFromServiceMeshRequest&, const RemoveClusterFromServiceMeshOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveClusterFromServiceMeshAsyncHandler;
+			typedef Outcome<Error, Model::RemoveVmAppFromMeshResult> RemoveVmAppFromMeshOutcome;
+			typedef std::future<RemoveVmAppFromMeshOutcome> RemoveVmAppFromMeshOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::RemoveVmAppFromMeshRequest&, const RemoveVmAppFromMeshOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveVmAppFromMeshAsyncHandler;
+			typedef Outcome<Error, Model::RunDiagnosisResult> RunDiagnosisOutcome;
+			typedef std::future<RunDiagnosisOutcome> RunDiagnosisOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::RunDiagnosisRequest&, const RunDiagnosisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RunDiagnosisAsyncHandler;
+			typedef Outcome<Error, Model::UpdateIstioInjectionConfigResult> UpdateIstioInjectionConfigOutcome;
+			typedef std::future<UpdateIstioInjectionConfigOutcome> UpdateIstioInjectionConfigOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::UpdateIstioInjectionConfigRequest&, const UpdateIstioInjectionConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateIstioInjectionConfigAsyncHandler;
+			typedef Outcome<Error, Model::UpdateMeshFeatureResult> UpdateMeshFeatureOutcome;
+			typedef std::future<UpdateMeshFeatureOutcome> UpdateMeshFeatureOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::UpdateMeshFeatureRequest&, const UpdateMeshFeatureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateMeshFeatureAsyncHandler;
+			typedef Outcome<Error, Model::UpgradeMeshVersionResult> UpgradeMeshVersionOutcome;
+			typedef std::future<UpgradeMeshVersionOutcome> UpgradeMeshVersionOutcomeCallable;
+			typedef std::function<void(const ServicemeshClient*, const Model::UpgradeMeshVersionRequest&, const UpgradeMeshVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpgradeMeshVersionAsyncHandler;
+
+			ServicemeshClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			ServicemeshClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			ServicemeshClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~ServicemeshClient();
+			AddClusterIntoServiceMeshOutcome addClusterIntoServiceMesh(const Model::AddClusterIntoServiceMeshRequest &request)const;
+			void addClusterIntoServiceMeshAsync(const Model::AddClusterIntoServiceMeshRequest& request, const AddClusterIntoServiceMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddClusterIntoServiceMeshOutcomeCallable addClusterIntoServiceMeshCallable(const Model::AddClusterIntoServiceMeshRequest& request) const;
+			AddVmAppToMeshOutcome addVmAppToMesh(const Model::AddVmAppToMeshRequest &request)const;
+			void addVmAppToMeshAsync(const Model::AddVmAppToMeshRequest& request, const AddVmAppToMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddVmAppToMeshOutcomeCallable addVmAppToMeshCallable(const Model::AddVmAppToMeshRequest& request) const;
+			CreateServiceMeshOutcome createServiceMesh(const Model::CreateServiceMeshRequest &request)const;
+			void createServiceMeshAsync(const Model::CreateServiceMeshRequest& request, const CreateServiceMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateServiceMeshOutcomeCallable createServiceMeshCallable(const Model::CreateServiceMeshRequest& request) const;
+			DeleteServiceMeshOutcome deleteServiceMesh(const Model::DeleteServiceMeshRequest &request)const;
+			void deleteServiceMeshAsync(const Model::DeleteServiceMeshRequest& request, const DeleteServiceMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteServiceMeshOutcomeCallable deleteServiceMeshCallable(const Model::DeleteServiceMeshRequest& request) const;
+			DescribeCensOutcome describeCens(const Model::DescribeCensRequest &request)const;
+			void describeCensAsync(const Model::DescribeCensRequest& request, const DescribeCensAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeCensOutcomeCallable describeCensCallable(const Model::DescribeCensRequest& request) const;
+			DescribeClusterGrafanaOutcome describeClusterGrafana(const Model::DescribeClusterGrafanaRequest &request)const;
+			void describeClusterGrafanaAsync(const Model::DescribeClusterGrafanaRequest& request, const DescribeClusterGrafanaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeClusterGrafanaOutcomeCallable describeClusterGrafanaCallable(const Model::DescribeClusterGrafanaRequest& request) const;
+			DescribeClusterPrometheusOutcome describeClusterPrometheus(const Model::DescribeClusterPrometheusRequest &request)const;
+			void describeClusterPrometheusAsync(const Model::DescribeClusterPrometheusRequest& request, const DescribeClusterPrometheusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeClusterPrometheusOutcomeCallable describeClusterPrometheusCallable(const Model::DescribeClusterPrometheusRequest& request) const;
+			DescribeClustersInServiceMeshOutcome describeClustersInServiceMesh(const Model::DescribeClustersInServiceMeshRequest &request)const;
+			void describeClustersInServiceMeshAsync(const Model::DescribeClustersInServiceMeshRequest& request, const DescribeClustersInServiceMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeClustersInServiceMeshOutcomeCallable describeClustersInServiceMeshCallable(const Model::DescribeClustersInServiceMeshRequest& request) const;
+			DescribeGuestClusterAccessLogDashboardsOutcome describeGuestClusterAccessLogDashboards(const Model::DescribeGuestClusterAccessLogDashboardsRequest &request)const;
+			void describeGuestClusterAccessLogDashboardsAsync(const Model::DescribeGuestClusterAccessLogDashboardsRequest& request, const DescribeGuestClusterAccessLogDashboardsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGuestClusterAccessLogDashboardsOutcomeCallable describeGuestClusterAccessLogDashboardsCallable(const Model::DescribeGuestClusterAccessLogDashboardsRequest& request) const;
+			DescribeIngressGatewaysOutcome describeIngressGateways(const Model::DescribeIngressGatewaysRequest &request)const;
+			void describeIngressGatewaysAsync(const Model::DescribeIngressGatewaysRequest& request, const DescribeIngressGatewaysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeIngressGatewaysOutcomeCallable describeIngressGatewaysCallable(const Model::DescribeIngressGatewaysRequest& request) const;
+			DescribeServiceMeshDetailOutcome describeServiceMeshDetail(const Model::DescribeServiceMeshDetailRequest &request)const;
+			void describeServiceMeshDetailAsync(const Model::DescribeServiceMeshDetailRequest& request, const DescribeServiceMeshDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeServiceMeshDetailOutcomeCallable describeServiceMeshDetailCallable(const Model::DescribeServiceMeshDetailRequest& request) const;
+			DescribeServiceMeshKubeconfigOutcome describeServiceMeshKubeconfig(const Model::DescribeServiceMeshKubeconfigRequest &request)const;
+			void describeServiceMeshKubeconfigAsync(const Model::DescribeServiceMeshKubeconfigRequest& request, const DescribeServiceMeshKubeconfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeServiceMeshKubeconfigOutcomeCallable describeServiceMeshKubeconfigCallable(const Model::DescribeServiceMeshKubeconfigRequest& request) const;
+			DescribeServiceMeshesOutcome describeServiceMeshes(const Model::DescribeServiceMeshesRequest &request)const;
+			void describeServiceMeshesAsync(const Model::DescribeServiceMeshesRequest& request, const DescribeServiceMeshesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeServiceMeshesOutcomeCallable describeServiceMeshesCallable(const Model::DescribeServiceMeshesRequest& request) const;
+			DescribeUpgradeVersionOutcome describeUpgradeVersion(const Model::DescribeUpgradeVersionRequest &request)const;
+			void describeUpgradeVersionAsync(const Model::DescribeUpgradeVersionRequest& request, const DescribeUpgradeVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeUpgradeVersionOutcomeCallable describeUpgradeVersionCallable(const Model::DescribeUpgradeVersionRequest& request) const;
+			GetDiagnosisOutcome getDiagnosis(const Model::GetDiagnosisRequest &request)const;
+			void getDiagnosisAsync(const Model::GetDiagnosisRequest& request, const GetDiagnosisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDiagnosisOutcomeCallable getDiagnosisCallable(const Model::GetDiagnosisRequest& request) const;
+			GetRegisteredServiceEndpointsOutcome getRegisteredServiceEndpoints(const Model::GetRegisteredServiceEndpointsRequest &request)const;
+			void getRegisteredServiceEndpointsAsync(const Model::GetRegisteredServiceEndpointsRequest& request, const GetRegisteredServiceEndpointsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetRegisteredServiceEndpointsOutcomeCallable getRegisteredServiceEndpointsCallable(const Model::GetRegisteredServiceEndpointsRequest& request) const;
+			GetRegisteredServiceNamespacesOutcome getRegisteredServiceNamespaces(const Model::GetRegisteredServiceNamespacesRequest &request)const;
+			void getRegisteredServiceNamespacesAsync(const Model::GetRegisteredServiceNamespacesRequest& request, const GetRegisteredServiceNamespacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetRegisteredServiceNamespacesOutcomeCallable getRegisteredServiceNamespacesCallable(const Model::GetRegisteredServiceNamespacesRequest& request) const;
+			GetRegisteredServicesOutcome getRegisteredServices(const Model::GetRegisteredServicesRequest &request)const;
+			void getRegisteredServicesAsync(const Model::GetRegisteredServicesRequest& request, const GetRegisteredServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetRegisteredServicesOutcomeCallable getRegisteredServicesCallable(const Model::GetRegisteredServicesRequest& request) const;
+			GetServiceMeshSlbOutcome getServiceMeshSlb(const Model::GetServiceMeshSlbRequest &request)const;
+			void getServiceMeshSlbAsync(const Model::GetServiceMeshSlbRequest& request, const GetServiceMeshSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetServiceMeshSlbOutcomeCallable getServiceMeshSlbCallable(const Model::GetServiceMeshSlbRequest& request) const;
+			GetVmAppMeshInfoOutcome getVmAppMeshInfo(const Model::GetVmAppMeshInfoRequest &request)const;
+			void getVmAppMeshInfoAsync(const Model::GetVmAppMeshInfoRequest& request, const GetVmAppMeshInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVmAppMeshInfoOutcomeCallable getVmAppMeshInfoCallable(const Model::GetVmAppMeshInfoRequest& request) const;
+			GetVmMetaOutcome getVmMeta(const Model::GetVmMetaRequest &request)const;
+			void getVmMetaAsync(const Model::GetVmMetaRequest& request, const GetVmMetaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVmMetaOutcomeCallable getVmMetaCallable(const Model::GetVmMetaRequest& request) const;
+			RemoveClusterFromServiceMeshOutcome removeClusterFromServiceMesh(const Model::RemoveClusterFromServiceMeshRequest &request)const;
+			void removeClusterFromServiceMeshAsync(const Model::RemoveClusterFromServiceMeshRequest& request, const RemoveClusterFromServiceMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveClusterFromServiceMeshOutcomeCallable removeClusterFromServiceMeshCallable(const Model::RemoveClusterFromServiceMeshRequest& request) const;
+			RemoveVmAppFromMeshOutcome removeVmAppFromMesh(const Model::RemoveVmAppFromMeshRequest &request)const;
+			void removeVmAppFromMeshAsync(const Model::RemoveVmAppFromMeshRequest& request, const RemoveVmAppFromMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveVmAppFromMeshOutcomeCallable removeVmAppFromMeshCallable(const Model::RemoveVmAppFromMeshRequest& request) const;
+			RunDiagnosisOutcome runDiagnosis(const Model::RunDiagnosisRequest &request)const;
+			void runDiagnosisAsync(const Model::RunDiagnosisRequest& request, const RunDiagnosisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RunDiagnosisOutcomeCallable runDiagnosisCallable(const Model::RunDiagnosisRequest& request) const;
+			UpdateIstioInjectionConfigOutcome updateIstioInjectionConfig(const Model::UpdateIstioInjectionConfigRequest &request)const;
+			void updateIstioInjectionConfigAsync(const Model::UpdateIstioInjectionConfigRequest& request, const UpdateIstioInjectionConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateIstioInjectionConfigOutcomeCallable updateIstioInjectionConfigCallable(const Model::UpdateIstioInjectionConfigRequest& request) const;
+			UpdateMeshFeatureOutcome updateMeshFeature(const Model::UpdateMeshFeatureRequest &request)const;
+			void updateMeshFeatureAsync(const Model::UpdateMeshFeatureRequest& request, const UpdateMeshFeatureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateMeshFeatureOutcomeCallable updateMeshFeatureCallable(const Model::UpdateMeshFeatureRequest& request) const;
+			UpgradeMeshVersionOutcome upgradeMeshVersion(const Model::UpgradeMeshVersionRequest &request)const;
+			void upgradeMeshVersionAsync(const Model::UpgradeMeshVersionRequest& request, const UpgradeMeshVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpgradeMeshVersionOutcomeCallable upgradeMeshVersionCallable(const Model::UpgradeMeshVersionRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_SERVICEMESH_SERVICEMESHCLIENT_H_

servicemesh/include/alibabacloud/servicemesh/ServicemeshExport.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_SERVICEMESH_SERVICEMESHEXPORT_H_
+#define ALIBABACLOUD_SERVICEMESH_SERVICEMESHEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_SERVICEMESH_LIBRARY)
+#		define ALIBABACLOUD_SERVICEMESH_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_SERVICEMESH_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_SERVICEMESH_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_SERVICEMESH_SERVICEMESHEXPORT_H_

servicemesh/include/alibabacloud/servicemesh/model/AddClusterIntoServiceMeshRequest.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_SERVICEMESH_MODEL_ADDCLUSTERINTOSERVICEMESHREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_ADDCLUSTERINTOSERVICEMESHREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT AddClusterIntoServiceMeshRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddClusterIntoServiceMeshRequest();
+				~AddClusterIntoServiceMeshRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string clusterId_;
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_ADDCLUSTERINTOSERVICEMESHREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/AddClusterIntoServiceMeshResult.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_SERVICEMESH_MODEL_ADDCLUSTERINTOSERVICEMESHRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_ADDCLUSTERINTOSERVICEMESHRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT AddClusterIntoServiceMeshResult : public ServiceResult
+			{
+			public:
+
+
+				AddClusterIntoServiceMeshResult();
+				explicit AddClusterIntoServiceMeshResult(const std::string &payload);
+				~AddClusterIntoServiceMeshResult();
+				std::string getMessage()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_ADDCLUSTERINTOSERVICEMESHRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/AddVmAppToMeshRequest.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_SERVICEMESH_MODEL_ADDVMAPPTOMESHREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_ADDVMAPPTOMESHREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT AddVmAppToMeshRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddVmAppToMeshRequest();
+				~AddVmAppToMeshRequest();
+
+				std::string getServiceAccount()const;
+				void setServiceAccount(const std::string& serviceAccount);
+				std::string getAnnotations()const;
+				void setAnnotations(const std::string& annotations);
+				std::string getPorts()const;
+				void setPorts(const std::string& ports);
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+				std::string getServiceName()const;
+				void setServiceName(const std::string& serviceName);
+				bool getUseWorkload()const;
+				void setUseWorkload(bool useWorkload);
+				std::string getIps()const;
+				void setIps(const std::string& ips);
+				std::string getLabels()const;
+				void setLabels(const std::string& labels);
+				std::string get_Namespace()const;
+				void set_Namespace(const std::string& _namespace);
+				bool getForce()const;
+				void setForce(bool force);
+
+            private:
+				std::string serviceAccount_;
+				std::string annotations_;
+				std::string ports_;
+				std::string serviceMeshId_;
+				std::string serviceName_;
+				bool useWorkload_;
+				std::string ips_;
+				std::string labels_;
+				std::string _namespace_;
+				bool force_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_ADDVMAPPTOMESHREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/AddVmAppToMeshResult.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_SERVICEMESH_MODEL_ADDVMAPPTOMESHRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_ADDVMAPPTOMESHRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT AddVmAppToMeshResult : public ServiceResult
+			{
+			public:
+
+
+				AddVmAppToMeshResult();
+				explicit AddVmAppToMeshResult(const std::string &payload);
+				~AddVmAppToMeshResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_ADDVMAPPTOMESHRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/CreateServiceMeshRequest.h

@@ -0,0 +1,147 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SERVICEMESH_MODEL_CREATESERVICEMESHREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_CREATESERVICEMESHREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT CreateServiceMeshRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateServiceMeshRequest();
+				~CreateServiceMeshRequest();
+
+				std::string getProxyRequestCPU()const;
+				void setProxyRequestCPU(const std::string& proxyRequestCPU);
+				std::string getOPALimitCPU()const;
+				void setOPALimitCPU(const std::string& oPALimitCPU);
+				bool getOpenAgentPolicy()const;
+				void setOpenAgentPolicy(bool openAgentPolicy);
+				bool getOpaEnabled()const;
+				void setOpaEnabled(bool opaEnabled);
+				std::string getProxyLimitMemory()const;
+				void setProxyLimitMemory(const std::string& proxyLimitMemory);
+				bool getStrictMTLS()const;
+				void setStrictMTLS(bool strictMTLS);
+				std::string getOPALogLevel()const;
+				void setOPALogLevel(const std::string& oPALogLevel);
+				std::string getExcludeIPRanges()const;
+				void setExcludeIPRanges(const std::string& excludeIPRanges);
+				std::string getIstioVersion()const;
+				void setIstioVersion(const std::string& istioVersion);
+				bool getTracing()const;
+				void setTracing(bool tracing);
+				std::string getIncludeIPRanges()const;
+				void setIncludeIPRanges(const std::string& includeIPRanges);
+				std::string getExcludeInboundPorts()const;
+				void setExcludeInboundPorts(const std::string& excludeInboundPorts);
+				std::string getOPALimitMemory()const;
+				void setOPALimitMemory(const std::string& oPALimitMemory);
+				std::string getVSwitches()const;
+				void setVSwitches(const std::string& vSwitches);
+				bool getCADisableSecretAutoGeneration()const;
+				void setCADisableSecretAutoGeneration(bool cADisableSecretAutoGeneration);
+				std::string getCAListenedNamespaces()const;
+				void setCAListenedNamespaces(const std::string& cAListenedNamespaces);
+				std::string getProxyLimitCPU()const;
+				void setProxyLimitCPU(const std::string& proxyLimitCPU);
+				std::string getProxyRequestMemory()const;
+				void setProxyRequestMemory(const std::string& proxyRequestMemory);
+				std::string getName()const;
+				void setName(const std::string& name);
+				bool getTelemetry()const;
+				void setTelemetry(bool telemetry);
+				std::string getOPARequestCPU()const;
+				void setOPARequestCPU(const std::string& oPARequestCPU);
+				std::string getOPARequestMemory()const;
+				void setOPARequestMemory(const std::string& oPARequestMemory);
+				bool getEnableAudit()const;
+				void setEnableAudit(bool enableAudit);
+				std::string getClusterDomain()const;
+				void setClusterDomain(const std::string& clusterDomain);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getLocalityLoadBalancing()const;
+				void setLocalityLoadBalancing(bool localityLoadBalancing);
+				bool getApiServerPublicEip()const;
+				void setApiServerPublicEip(bool apiServerPublicEip);
+				float getTraceSampling()const;
+				void setTraceSampling(float traceSampling);
+				std::string getAppNamespaces()const;
+				void setAppNamespaces(const std::string& appNamespaces);
+				bool getPilotPublicEip()const;
+				void setPilotPublicEip(bool pilotPublicEip);
+				std::string getAuditProject()const;
+				void setAuditProject(const std::string& auditProject);
+				std::string getOutboundTrafficPolicy()const;
+				void setOutboundTrafficPolicy(const std::string& outboundTrafficPolicy);
+				std::string getVpcId()const;
+				void setVpcId(const std::string& vpcId);
+				std::string getExcludeOutboundPorts()const;
+				void setExcludeOutboundPorts(const std::string& excludeOutboundPorts);
+
+            private:
+				std::string proxyRequestCPU_;
+				std::string oPALimitCPU_;
+				bool openAgentPolicy_;
+				bool opaEnabled_;
+				std::string proxyLimitMemory_;
+				bool strictMTLS_;
+				std::string oPALogLevel_;
+				std::string excludeIPRanges_;
+				std::string istioVersion_;
+				bool tracing_;
+				std::string includeIPRanges_;
+				std::string excludeInboundPorts_;
+				std::string oPALimitMemory_;
+				std::string vSwitches_;
+				bool cADisableSecretAutoGeneration_;
+				std::string cAListenedNamespaces_;
+				std::string proxyLimitCPU_;
+				std::string proxyRequestMemory_;
+				std::string name_;
+				bool telemetry_;
+				std::string oPARequestCPU_;
+				std::string oPARequestMemory_;
+				bool enableAudit_;
+				std::string clusterDomain_;
+				std::string regionId_;
+				bool localityLoadBalancing_;
+				bool apiServerPublicEip_;
+				float traceSampling_;
+				std::string appNamespaces_;
+				bool pilotPublicEip_;
+				std::string auditProject_;
+				std::string outboundTrafficPolicy_;
+				std::string vpcId_;
+				std::string excludeOutboundPorts_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_CREATESERVICEMESHREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/CreateServiceMeshResult.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_SERVICEMESH_MODEL_CREATESERVICEMESHRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_CREATESERVICEMESHRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT CreateServiceMeshResult : public ServiceResult
+			{
+			public:
+
+
+				CreateServiceMeshResult();
+				explicit CreateServiceMeshResult(const std::string &payload);
+				~CreateServiceMeshResult();
+				std::string getServiceMeshId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_CREATESERVICEMESHRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/DeleteServiceMeshRequest.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_SERVICEMESH_MODEL_DELETESERVICEMESHREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DELETESERVICEMESHREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DeleteServiceMeshRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteServiceMeshRequest();
+				~DeleteServiceMeshRequest();
+
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+				bool getForce()const;
+				void setForce(bool force);
+
+            private:
+				std::string serviceMeshId_;
+				bool force_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DELETESERVICEMESHREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/DeleteServiceMeshResult.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_SERVICEMESH_MODEL_DELETESERVICEMESHRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DELETESERVICEMESHRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DeleteServiceMeshResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteServiceMeshResult();
+				explicit DeleteServiceMeshResult(const std::string &payload);
+				~DeleteServiceMeshResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DELETESERVICEMESHRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeCensRequest.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_SERVICEMESH_MODEL_DESCRIBECENSREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECENSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeCensRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeCensRequest();
+				~DescribeCensRequest();
+
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECENSREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeCensResult.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_SERVICEMESH_MODEL_DESCRIBECENSRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECENSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeCensResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeCensResult();
+				explicit DescribeCensResult(const std::string &payload);
+				~DescribeCensResult();
+				std::vector<std::string> getClusters()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> clusters_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECENSRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeClusterGrafanaRequest.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_SERVICEMESH_MODEL_DESCRIBECLUSTERGRAFANAREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECLUSTERGRAFANAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeClusterGrafanaRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeClusterGrafanaRequest();
+				~DescribeClusterGrafanaRequest();
+
+				std::string getK8sClusterId()const;
+				void setK8sClusterId(const std::string& k8sClusterId);
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string k8sClusterId_;
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECLUSTERGRAFANAREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeClusterGrafanaResult.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_SERVICEMESH_MODEL_DESCRIBECLUSTERGRAFANARESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECLUSTERGRAFANARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeClusterGrafanaResult : public ServiceResult
+			{
+			public:
+				struct Dashboard
+				{
+					std::string title;
+					std::string url;
+				};
+
+
+				DescribeClusterGrafanaResult();
+				explicit DescribeClusterGrafanaResult(const std::string &payload);
+				~DescribeClusterGrafanaResult();
+				std::vector<Dashboard> getDashboards()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Dashboard> dashboards_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECLUSTERGRAFANARESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeClusterPrometheusRequest.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_SERVICEMESH_MODEL_DESCRIBECLUSTERPROMETHEUSREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECLUSTERPROMETHEUSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeClusterPrometheusRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeClusterPrometheusRequest();
+				~DescribeClusterPrometheusRequest();
+
+				std::string getK8sClusterId()const;
+				void setK8sClusterId(const std::string& k8sClusterId);
+				std::string getK8sClusterRegionId()const;
+				void setK8sClusterRegionId(const std::string& k8sClusterRegionId);
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string k8sClusterId_;
+				std::string k8sClusterRegionId_;
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECLUSTERPROMETHEUSREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeClusterPrometheusResult.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_SERVICEMESH_MODEL_DESCRIBECLUSTERPROMETHEUSRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECLUSTERPROMETHEUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeClusterPrometheusResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeClusterPrometheusResult();
+				explicit DescribeClusterPrometheusResult(const std::string &payload);
+				~DescribeClusterPrometheusResult();
+				std::string getPrometheus()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string prometheus_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECLUSTERPROMETHEUSRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeClustersInServiceMeshRequest.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_SERVICEMESH_MODEL_DESCRIBECLUSTERSINSERVICEMESHREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECLUSTERSINSERVICEMESHREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeClustersInServiceMeshRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeClustersInServiceMeshRequest();
+				~DescribeClustersInServiceMeshRequest();
+
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECLUSTERSINSERVICEMESHREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeClustersInServiceMeshResult.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECLUSTERSINSERVICEMESHRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECLUSTERSINSERVICEMESHRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeClustersInServiceMeshResult : public ServiceResult
+			{
+			public:
+				struct Cluster
+				{
+					std::string vpcId;
+					std::string clusterId;
+					std::string version;
+					std::string state;
+					std::string clusterDomain;
+					std::string creationTime;
+					std::string updateTime;
+					std::string sgId;
+					std::string clusterType;
+					std::string regionId;
+					std::string errorMessage;
+					std::string name;
+				};
+
+
+				DescribeClustersInServiceMeshResult();
+				explicit DescribeClustersInServiceMeshResult(const std::string &payload);
+				~DescribeClustersInServiceMeshResult();
+				std::vector<Cluster> getClusters()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Cluster> clusters_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBECLUSTERSINSERVICEMESHRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeGuestClusterAccessLogDashboardsRequest.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_SERVICEMESH_MODEL_DESCRIBEGUESTCLUSTERACCESSLOGDASHBOARDSREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBEGUESTCLUSTERACCESSLOGDASHBOARDSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeGuestClusterAccessLogDashboardsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeGuestClusterAccessLogDashboardsRequest();
+				~DescribeGuestClusterAccessLogDashboardsRequest();
+
+				std::string getK8sClusterId()const;
+				void setK8sClusterId(const std::string& k8sClusterId);
+
+            private:
+				std::string k8sClusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBEGUESTCLUSTERACCESSLOGDASHBOARDSREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeGuestClusterAccessLogDashboardsResult.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_SERVICEMESH_MODEL_DESCRIBEGUESTCLUSTERACCESSLOGDASHBOARDSRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBEGUESTCLUSTERACCESSLOGDASHBOARDSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeGuestClusterAccessLogDashboardsResult : public ServiceResult
+			{
+			public:
+				struct DashboardsItem
+				{
+					std::string title;
+					std::string url;
+				};
+
+
+				DescribeGuestClusterAccessLogDashboardsResult();
+				explicit DescribeGuestClusterAccessLogDashboardsResult(const std::string &payload);
+				~DescribeGuestClusterAccessLogDashboardsResult();
+				std::vector<DashboardsItem> getDashboards()const;
+				std::string getK8sClusterId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<DashboardsItem> dashboards_;
+				std::string k8sClusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBEGUESTCLUSTERACCESSLOGDASHBOARDSRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeIngressGatewaysRequest.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_SERVICEMESH_MODEL_DESCRIBEINGRESSGATEWAYSREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBEINGRESSGATEWAYSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeIngressGatewaysRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeIngressGatewaysRequest();
+				~DescribeIngressGatewaysRequest();
+
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBEINGRESSGATEWAYSREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeIngressGatewaysResult.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_SERVICEMESH_MODEL_DESCRIBEINGRESSGATEWAYSRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBEINGRESSGATEWAYSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeIngressGatewaysResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeIngressGatewaysResult();
+				explicit DescribeIngressGatewaysResult(const std::string &payload);
+				~DescribeIngressGatewaysResult();
+				std::vector<std::string> getIngressGateways()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> ingressGateways_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBEINGRESSGATEWAYSRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeServiceMeshDetailRequest.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_SERVICEMESH_MODEL_DESCRIBESERVICEMESHDETAILREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBESERVICEMESHDETAILREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeServiceMeshDetailRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeServiceMeshDetailRequest();
+				~DescribeServiceMeshDetailRequest();
+
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBESERVICEMESHDETAILREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeServiceMeshDetailResult.h

@@ -0,0 +1,152 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBESERVICEMESHDETAILRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBESERVICEMESHDETAILRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeServiceMeshDetailResult : public ServiceResult
+			{
+			public:
+				struct ServiceMesh
+				{
+					struct Endpoints
+					{
+						std::string publicPilotEndpoint;
+						std::string intranetApiServerEndpoint;
+						std::string intranetPilotEndpoint;
+						std::string publicApiServerEndpoint;
+					};
+					struct ServiceMeshInfo
+					{
+						std::string serviceMeshId;
+						std::string version;
+						std::string state;
+						std::string creationTime;
+						std::string updateTime;
+						std::string regionId;
+						std::string errorMessage;
+						std::string name;
+					};
+					struct Spec
+					{
+						struct LoadBalancer
+						{
+							std::string apiServerLoadbalancerId;
+							bool pilotPublicEip;
+							std::string pilotPublicLoadbalancerId;
+							bool apiServerPublicEip;
+						};
+						struct MeshConfig
+						{
+							struct Pilot
+							{
+								float traceSampling;
+								bool http10Enabled;
+							};
+							struct OPA
+							{
+								std::string limitMemory;
+								std::string requestMemory;
+								std::string limitCPU;
+								bool enabled;
+								std::string logLevel;
+								std::string requestCPU;
+							};
+							struct Audit
+							{
+								std::string project;
+								bool enabled;
+							};
+							struct Proxy
+							{
+								std::string limitMemory;
+								std::string requestMemory;
+								std::string clusterDomain;
+								std::string limitCPU;
+								std::string requestCPU;
+							};
+							struct SidecarInjector
+							{
+								struct InitCNIConfiguration
+								{
+									bool enabled;
+									std::string excludeNamespaces;
+								};
+								bool autoInjectionPolicyEnabled;
+								std::string limitMemory;
+								std::string requestMemory;
+								bool enableNamespacesByDefault;
+								std::string limitCPU;
+								InitCNIConfiguration initCNIConfiguration;
+								std::string requestCPU;
+								std::string sidecarInjectorWebhookAsYaml;
+							};
+							Pilot pilot;
+							SidecarInjector sidecarInjector;
+							OPA oPA;
+							Audit audit;
+							Proxy proxy;
+							std::string includeIPRanges;
+							bool enableLocalityLB;
+							bool tracing;
+							bool telemetry;
+							std::string outboundTrafficPolicy;
+							bool customizedZipkin;
+						};
+						struct Network
+						{
+							std::string vpcId;
+							std::string securityGroupId;
+							std::vector<std::string> vSwitches;
+						};
+						MeshConfig meshConfig;
+						Network network;
+						LoadBalancer loadBalancer;
+					};
+					Endpoints endpoints;
+					std::vector<std::string> clusters;
+					ServiceMeshInfo serviceMeshInfo;
+					Spec spec;
+				};
+
+
+				DescribeServiceMeshDetailResult();
+				explicit DescribeServiceMeshDetailResult(const std::string &payload);
+				~DescribeServiceMeshDetailResult();
+				ServiceMesh getServiceMesh()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ServiceMesh serviceMesh_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBESERVICEMESHDETAILRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeServiceMeshKubeconfigRequest.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_SERVICEMESH_MODEL_DESCRIBESERVICEMESHKUBECONFIGREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBESERVICEMESHKUBECONFIGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeServiceMeshKubeconfigRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeServiceMeshKubeconfigRequest();
+				~DescribeServiceMeshKubeconfigRequest();
+
+				bool getPrivateIpAddress()const;
+				void setPrivateIpAddress(bool privateIpAddress);
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				bool privateIpAddress_;
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBESERVICEMESHKUBECONFIGREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeServiceMeshKubeconfigResult.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_SERVICEMESH_MODEL_DESCRIBESERVICEMESHKUBECONFIGRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBESERVICEMESHKUBECONFIGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeServiceMeshKubeconfigResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeServiceMeshKubeconfigResult();
+				explicit DescribeServiceMeshKubeconfigResult(const std::string &payload);
+				~DescribeServiceMeshKubeconfigResult();
+				std::string getKubeconfig()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string kubeconfig_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBESERVICEMESHKUBECONFIGRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeServiceMeshesRequest.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_SERVICEMESH_MODEL_DESCRIBESERVICEMESHESREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBESERVICEMESHESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeServiceMeshesRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeServiceMeshesRequest();
+				~DescribeServiceMeshesRequest();
+
+
+            private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBESERVICEMESHESREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeServiceMeshesResult.h

@@ -0,0 +1,122 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SERVICEMESH_MODEL_DESCRIBESERVICEMESHESRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBESERVICEMESHESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeServiceMeshesResult : public ServiceResult
+			{
+			public:
+				struct ServiceMesh
+				{
+					struct Endpoints
+					{
+						std::string publicPilotEndpoint;
+						std::string reverseTunnelEndpoint;
+						std::string intranetApiServerEndpoint;
+						std::string intranetPilotEndpoint;
+						std::string publicApiServerEndpoint;
+					};
+					struct ServiceMeshInfo
+					{
+						std::string serviceMeshId;
+						std::string version;
+						std::string state;
+						std::string creationTime;
+						std::string updateTime;
+						std::string regionId;
+						std::string errorMessage;
+						std::string name;
+					};
+					struct Spec
+					{
+						struct LoadBalancer
+						{
+							std::string apiServerLoadbalancerId;
+							bool pilotPublicEip;
+							std::string pilotPublicLoadbalancerId;
+							bool apiServerPublicEip;
+						};
+						struct MeshConfig
+						{
+							struct Pilot
+							{
+								float traceSampling;
+								bool http10Enabled;
+							};
+							struct SidecarInjector
+							{
+								struct InitCNIConfiguration
+								{
+									bool enabled;
+									std::string excludeNamespaces;
+								};
+								bool autoInjectionPolicyEnabled;
+								bool enableNamespacesByDefault;
+								InitCNIConfiguration initCNIConfiguration;
+							};
+							Pilot pilot;
+							SidecarInjector sidecarInjector;
+							bool mtls;
+							bool strictMtls;
+							bool tracing;
+							std::string outboundTrafficPolicy;
+							bool telemetry;
+						};
+						struct Network
+						{
+							std::string vpcId;
+							std::string securityGroupId;
+							std::vector<std::string> vSwitches;
+						};
+						MeshConfig meshConfig;
+						Network network;
+						LoadBalancer loadBalancer;
+					};
+					Endpoints endpoints;
+					std::vector<std::string> clusters;
+					ServiceMeshInfo serviceMeshInfo;
+					Spec spec;
+				};
+
+
+				DescribeServiceMeshesResult();
+				explicit DescribeServiceMeshesResult(const std::string &payload);
+				~DescribeServiceMeshesResult();
+				std::vector<ServiceMesh> getServiceMeshes()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<ServiceMesh> serviceMeshes_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBESERVICEMESHESRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeUpgradeVersionRequest.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_SERVICEMESH_MODEL_DESCRIBEUPGRADEVERSIONREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBEUPGRADEVERSIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeUpgradeVersionRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeUpgradeVersionRequest();
+				~DescribeUpgradeVersionRequest();
+
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBEUPGRADEVERSIONREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/DescribeUpgradeVersionResult.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_SERVICEMESH_MODEL_DESCRIBEUPGRADEVERSIONRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBEUPGRADEVERSIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT DescribeUpgradeVersionResult : public ServiceResult
+			{
+			public:
+				struct Version
+				{
+					std::string kubernetesVersion;
+					std::string istioVersion;
+					std::string istioOperatorVersion;
+				};
+
+
+				DescribeUpgradeVersionResult();
+				explicit DescribeUpgradeVersionResult(const std::string &payload);
+				~DescribeUpgradeVersionResult();
+				Version getVersion()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Version version_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_DESCRIBEUPGRADEVERSIONRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/GetDiagnosisRequest.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_SERVICEMESH_MODEL_GETDIAGNOSISREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_GETDIAGNOSISREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT GetDiagnosisRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetDiagnosisRequest();
+				~GetDiagnosisRequest();
+
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_GETDIAGNOSISREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/GetDiagnosisResult.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_SERVICEMESH_MODEL_GETDIAGNOSISRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_GETDIAGNOSISRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT GetDiagnosisResult : public ServiceResult
+			{
+			public:
+
+
+				GetDiagnosisResult();
+				explicit GetDiagnosisResult(const std::string &payload);
+				~GetDiagnosisResult();
+				std::string getRunAt()const;
+				std::string getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string runAt_;
+				std::string result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_GETDIAGNOSISRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/GetRegisteredServiceEndpointsRequest.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_SERVICEMESH_MODEL_GETREGISTEREDSERVICEENDPOINTSREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_GETREGISTEREDSERVICEENDPOINTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT GetRegisteredServiceEndpointsRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetRegisteredServiceEndpointsRequest();
+				~GetRegisteredServiceEndpointsRequest();
+
+				std::string get_Namespace()const;
+				void set_Namespace(const std::string& _namespace);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string _namespace_;
+				std::string name_;
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_GETREGISTEREDSERVICEENDPOINTSREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/GetRegisteredServiceEndpointsResult.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_SERVICEMESH_MODEL_GETREGISTEREDSERVICEENDPOINTSRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_GETREGISTEREDSERVICEENDPOINTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT GetRegisteredServiceEndpointsResult : public ServiceResult
+			{
+			public:
+				struct ServiceEndpoint
+				{
+					std::string address;
+					std::string clusterId;
+				};
+
+
+				GetRegisteredServiceEndpointsResult();
+				explicit GetRegisteredServiceEndpointsResult(const std::string &payload);
+				~GetRegisteredServiceEndpointsResult();
+				std::vector<ServiceEndpoint> getServiceEndpoints()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<ServiceEndpoint> serviceEndpoints_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_GETREGISTEREDSERVICEENDPOINTSRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/GetRegisteredServiceNamespacesRequest.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_SERVICEMESH_MODEL_GETREGISTEREDSERVICENAMESPACESREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_GETREGISTEREDSERVICENAMESPACESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT GetRegisteredServiceNamespacesRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetRegisteredServiceNamespacesRequest();
+				~GetRegisteredServiceNamespacesRequest();
+
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_GETREGISTEREDSERVICENAMESPACESREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/GetRegisteredServiceNamespacesResult.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_SERVICEMESH_MODEL_GETREGISTEREDSERVICENAMESPACESRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_GETREGISTEREDSERVICENAMESPACESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT GetRegisteredServiceNamespacesResult : public ServiceResult
+			{
+			public:
+
+
+				GetRegisteredServiceNamespacesResult();
+				explicit GetRegisteredServiceNamespacesResult(const std::string &payload);
+				~GetRegisteredServiceNamespacesResult();
+				std::vector<std::string> getNamespaces()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> namespaces_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_GETREGISTEREDSERVICENAMESPACESRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/GetRegisteredServicesRequest.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_SERVICEMESH_MODEL_GETREGISTEREDSERVICESREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_GETREGISTEREDSERVICESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT GetRegisteredServicesRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetRegisteredServicesRequest();
+				~GetRegisteredServicesRequest();
+
+				std::string get_Namespace()const;
+				void set_Namespace(const std::string& _namespace);
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string _namespace_;
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_GETREGISTEREDSERVICESREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/GetRegisteredServicesResult.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_SERVICEMESH_MODEL_GETREGISTEREDSERVICESRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_GETREGISTEREDSERVICESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT GetRegisteredServicesResult : public ServiceResult
+			{
+			public:
+
+
+				GetRegisteredServicesResult();
+				explicit GetRegisteredServicesResult(const std::string &payload);
+				~GetRegisteredServicesResult();
+				std::vector<std::string> getServices()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> services_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_GETREGISTEREDSERVICESRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/GetServiceMeshSlbRequest.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_SERVICEMESH_MODEL_GETSERVICEMESHSLBREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_GETSERVICEMESHSLBREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT GetServiceMeshSlbRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetServiceMeshSlbRequest();
+				~GetServiceMeshSlbRequest();
+
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_GETSERVICEMESHSLBREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/GetServiceMeshSlbResult.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_SERVICEMESH_MODEL_GETSERVICEMESHSLBRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_GETSERVICEMESHSLBRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT GetServiceMeshSlbResult : public ServiceResult
+			{
+			public:
+				struct SLBInfo
+				{
+					std::string status;
+					std::string serverHealthStatus;
+					std::string loadBalancerId;
+				};
+
+
+				GetServiceMeshSlbResult();
+				explicit GetServiceMeshSlbResult(const std::string &payload);
+				~GetServiceMeshSlbResult();
+				std::vector<SLBInfo> getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<SLBInfo> data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_GETSERVICEMESHSLBRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/GetVmAppMeshInfoRequest.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_SERVICEMESH_MODEL_GETVMAPPMESHINFOREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_GETVMAPPMESHINFOREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT GetVmAppMeshInfoRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetVmAppMeshInfoRequest();
+				~GetVmAppMeshInfoRequest();
+
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_GETVMAPPMESHINFOREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/GetVmAppMeshInfoResult.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_SERVICEMESH_MODEL_GETVMAPPMESHINFORESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_GETVMAPPMESHINFORESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT GetVmAppMeshInfoResult : public ServiceResult
+			{
+			public:
+
+
+				GetVmAppMeshInfoResult();
+				explicit GetVmAppMeshInfoResult(const std::string &payload);
+				~GetVmAppMeshInfoResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_GETVMAPPMESHINFORESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/GetVmMetaRequest.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_SERVICEMESH_MODEL_GETVMMETAREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_GETVMMETAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT GetVmMetaRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetVmMetaRequest();
+				~GetVmMetaRequest();
+
+				std::string getServiceAccount()const;
+				void setServiceAccount(const std::string& serviceAccount);
+				std::string getTrustDomain()const;
+				void setTrustDomain(const std::string& trustDomain);
+				std::string get_Namespace()const;
+				void set_Namespace(const std::string& _namespace);
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string serviceAccount_;
+				std::string trustDomain_;
+				std::string _namespace_;
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_GETVMMETAREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/GetVmMetaResult.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SERVICEMESH_MODEL_GETVMMETARESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_GETVMMETARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT GetVmMetaResult : public ServiceResult
+			{
+			public:
+				struct VmMetaInfo
+				{
+					std::string envoyEnvContent;
+					std::string tokenPath;
+					std::string certChainPath;
+					std::string certChainContent;
+					std::string rootCertPath;
+					std::string rootCertContent;
+					std::string tokenContent;
+					std::string envoyEnvPath;
+					std::string hostsContent;
+					std::string hostsPath;
+					std::string keyContent;
+					std::string keyPath;
+				};
+
+
+				GetVmMetaResult();
+				explicit GetVmMetaResult(const std::string &payload);
+				~GetVmMetaResult();
+				VmMetaInfo getVmMetaInfo()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				VmMetaInfo vmMetaInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_GETVMMETARESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/RemoveClusterFromServiceMeshRequest.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_SERVICEMESH_MODEL_REMOVECLUSTERFROMSERVICEMESHREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_REMOVECLUSTERFROMSERVICEMESHREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT RemoveClusterFromServiceMeshRequest : public RpcServiceRequest
+			{
+
+			public:
+				RemoveClusterFromServiceMeshRequest();
+				~RemoveClusterFromServiceMeshRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string clusterId_;
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_REMOVECLUSTERFROMSERVICEMESHREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/RemoveClusterFromServiceMeshResult.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_SERVICEMESH_MODEL_REMOVECLUSTERFROMSERVICEMESHRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_REMOVECLUSTERFROMSERVICEMESHRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT RemoveClusterFromServiceMeshResult : public ServiceResult
+			{
+			public:
+
+
+				RemoveClusterFromServiceMeshResult();
+				explicit RemoveClusterFromServiceMeshResult(const std::string &payload);
+				~RemoveClusterFromServiceMeshResult();
+				std::string getMessage()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_REMOVECLUSTERFROMSERVICEMESHRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/RemoveVmAppFromMeshRequest.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_SERVICEMESH_MODEL_REMOVEVMAPPFROMMESHREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_REMOVEVMAPPFROMMESHREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT RemoveVmAppFromMeshRequest : public RpcServiceRequest
+			{
+
+			public:
+				RemoveVmAppFromMeshRequest();
+				~RemoveVmAppFromMeshRequest();
+
+				std::string get_Namespace()const;
+				void set_Namespace(const std::string& _namespace);
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+				std::string getServiceName()const;
+				void setServiceName(const std::string& serviceName);
+
+            private:
+				std::string _namespace_;
+				std::string serviceMeshId_;
+				std::string serviceName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_REMOVEVMAPPFROMMESHREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/RemoveVmAppFromMeshResult.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_SERVICEMESH_MODEL_REMOVEVMAPPFROMMESHRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_REMOVEVMAPPFROMMESHRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT RemoveVmAppFromMeshResult : public ServiceResult
+			{
+			public:
+
+
+				RemoveVmAppFromMeshResult();
+				explicit RemoveVmAppFromMeshResult(const std::string &payload);
+				~RemoveVmAppFromMeshResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_REMOVEVMAPPFROMMESHRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/RunDiagnosisRequest.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_SERVICEMESH_MODEL_RUNDIAGNOSISREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_RUNDIAGNOSISREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT RunDiagnosisRequest : public RpcServiceRequest
+			{
+
+			public:
+				RunDiagnosisRequest();
+				~RunDiagnosisRequest();
+
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_RUNDIAGNOSISREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/RunDiagnosisResult.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_SERVICEMESH_MODEL_RUNDIAGNOSISRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_RUNDIAGNOSISRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT RunDiagnosisResult : public ServiceResult
+			{
+			public:
+
+
+				RunDiagnosisResult();
+				explicit RunDiagnosisResult(const std::string &payload);
+				~RunDiagnosisResult();
+				std::string getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_RUNDIAGNOSISRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/UpdateIstioInjectionConfigRequest.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_SERVICEMESH_MODEL_UPDATEISTIOINJECTIONCONFIGREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_UPDATEISTIOINJECTIONCONFIGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT UpdateIstioInjectionConfigRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateIstioInjectionConfigRequest();
+				~UpdateIstioInjectionConfigRequest();
+
+				bool getEnableIstioInjection()const;
+				void setEnableIstioInjection(bool enableIstioInjection);
+				std::string get_Namespace()const;
+				void set_Namespace(const std::string& _namespace);
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				bool enableIstioInjection_;
+				std::string _namespace_;
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_UPDATEISTIOINJECTIONCONFIGREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/UpdateIstioInjectionConfigResult.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_SERVICEMESH_MODEL_UPDATEISTIOINJECTIONCONFIGRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_UPDATEISTIOINJECTIONCONFIGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT UpdateIstioInjectionConfigResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateIstioInjectionConfigResult();
+				explicit UpdateIstioInjectionConfigResult(const std::string &payload);
+				~UpdateIstioInjectionConfigResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_UPDATEISTIOINJECTIONCONFIGRESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/UpdateMeshFeatureRequest.h

@@ -0,0 +1,153 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SERVICEMESH_MODEL_UPDATEMESHFEATUREREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_UPDATEMESHFEATUREREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT UpdateMeshFeatureRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateMeshFeatureRequest();
+				~UpdateMeshFeatureRequest();
+
+				std::string getProxyRequestCPU()const;
+				void setProxyRequestCPU(const std::string& proxyRequestCPU);
+				std::string getOPALimitCPU()const;
+				void setOPALimitCPU(const std::string& oPALimitCPU);
+				bool getOpenAgentPolicy()const;
+				void setOpenAgentPolicy(bool openAgentPolicy);
+				bool getOpaEnabled()const;
+				void setOpaEnabled(bool opaEnabled);
+				std::string getProxyLimitMemory()const;
+				void setProxyLimitMemory(const std::string& proxyLimitMemory);
+				std::string getCniExcludeNamespaces()const;
+				void setCniExcludeNamespaces(const std::string& cniExcludeNamespaces);
+				std::string getOPALogLevel()const;
+				void setOPALogLevel(const std::string& oPALogLevel);
+				bool getCustomizedZipkin()const;
+				void setCustomizedZipkin(bool customizedZipkin);
+				std::string getSidecarInjectorRequestCPU()const;
+				void setSidecarInjectorRequestCPU(const std::string& sidecarInjectorRequestCPU);
+				bool getCniEnabled()const;
+				void setCniEnabled(bool cniEnabled);
+				bool getTracing()const;
+				void setTracing(bool tracing);
+				std::string getIncludeIPRanges()const;
+				void setIncludeIPRanges(const std::string& includeIPRanges);
+				std::string getOPALimitMemory()const;
+				void setOPALimitMemory(const std::string& oPALimitMemory);
+				bool getCADisableSecretAutoGeneration()const;
+				void setCADisableSecretAutoGeneration(bool cADisableSecretAutoGeneration);
+				std::string getCAListenedNamespaces()const;
+				void setCAListenedNamespaces(const std::string& cAListenedNamespaces);
+				std::string getProxyLimitCPU()const;
+				void setProxyLimitCPU(const std::string& proxyLimitCPU);
+				std::string getProxyRequestMemory()const;
+				void setProxyRequestMemory(const std::string& proxyRequestMemory);
+				bool getTelemetry()const;
+				void setTelemetry(bool telemetry);
+				std::string getOPARequestCPU()const;
+				void setOPARequestCPU(const std::string& oPARequestCPU);
+				std::string getSidecarInjectorWebhookAsYaml()const;
+				void setSidecarInjectorWebhookAsYaml(const std::string& sidecarInjectorWebhookAsYaml);
+				std::string getOPARequestMemory()const;
+				void setOPARequestMemory(const std::string& oPARequestMemory);
+				bool getAutoInjectionPolicyEnabled()const;
+				void setAutoInjectionPolicyEnabled(bool autoInjectionPolicyEnabled);
+				std::string getSidecarInjectorLimitMemory()const;
+				void setSidecarInjectorLimitMemory(const std::string& sidecarInjectorLimitMemory);
+				bool getEnableAudit()const;
+				void setEnableAudit(bool enableAudit);
+				std::string getClusterDomain()const;
+				void setClusterDomain(const std::string& clusterDomain);
+				std::string getSidecarInjectorRequestMemory()const;
+				void setSidecarInjectorRequestMemory(const std::string& sidecarInjectorRequestMemory);
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+				bool getLocalityLoadBalancing()const;
+				void setLocalityLoadBalancing(bool localityLoadBalancing);
+				std::string getSidecarInjectorLimitCPU()const;
+				void setSidecarInjectorLimitCPU(const std::string& sidecarInjectorLimitCPU);
+				float getTraceSampling()const;
+				void setTraceSampling(float traceSampling);
+				bool getHttp10Enabled()const;
+				void setHttp10Enabled(bool http10Enabled);
+				std::string getAppNamespaces()const;
+				void setAppNamespaces(const std::string& appNamespaces);
+				bool getPilotPublicEip()const;
+				void setPilotPublicEip(bool pilotPublicEip);
+				std::string getAuditProject()const;
+				void setAuditProject(const std::string& auditProject);
+				std::string getOutboundTrafficPolicy()const;
+				void setOutboundTrafficPolicy(const std::string& outboundTrafficPolicy);
+				bool getEnableNamespacesByDefault()const;
+				void setEnableNamespacesByDefault(bool enableNamespacesByDefault);
+
+            private:
+				std::string proxyRequestCPU_;
+				std::string oPALimitCPU_;
+				bool openAgentPolicy_;
+				bool opaEnabled_;
+				std::string proxyLimitMemory_;
+				std::string cniExcludeNamespaces_;
+				std::string oPALogLevel_;
+				bool customizedZipkin_;
+				std::string sidecarInjectorRequestCPU_;
+				bool cniEnabled_;
+				bool tracing_;
+				std::string includeIPRanges_;
+				std::string oPALimitMemory_;
+				bool cADisableSecretAutoGeneration_;
+				std::string cAListenedNamespaces_;
+				std::string proxyLimitCPU_;
+				std::string proxyRequestMemory_;
+				bool telemetry_;
+				std::string oPARequestCPU_;
+				std::string sidecarInjectorWebhookAsYaml_;
+				std::string oPARequestMemory_;
+				bool autoInjectionPolicyEnabled_;
+				std::string sidecarInjectorLimitMemory_;
+				bool enableAudit_;
+				std::string clusterDomain_;
+				std::string sidecarInjectorRequestMemory_;
+				std::string serviceMeshId_;
+				bool localityLoadBalancing_;
+				std::string sidecarInjectorLimitCPU_;
+				float traceSampling_;
+				bool http10Enabled_;
+				std::string appNamespaces_;
+				bool pilotPublicEip_;
+				std::string auditProject_;
+				std::string outboundTrafficPolicy_;
+				bool enableNamespacesByDefault_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_UPDATEMESHFEATUREREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/UpdateMeshFeatureResult.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_SERVICEMESH_MODEL_UPDATEMESHFEATURERESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_UPDATEMESHFEATURERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT UpdateMeshFeatureResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateMeshFeatureResult();
+				explicit UpdateMeshFeatureResult(const std::string &payload);
+				~UpdateMeshFeatureResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_UPDATEMESHFEATURERESULT_H_

servicemesh/include/alibabacloud/servicemesh/model/UpgradeMeshVersionRequest.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_SERVICEMESH_MODEL_UPGRADEMESHVERSIONREQUEST_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_UPGRADEMESHVERSIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT UpgradeMeshVersionRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpgradeMeshVersionRequest();
+				~UpgradeMeshVersionRequest();
+
+				std::string getServiceMeshId()const;
+				void setServiceMeshId(const std::string& serviceMeshId);
+
+            private:
+				std::string serviceMeshId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_UPGRADEMESHVERSIONREQUEST_H_

servicemesh/include/alibabacloud/servicemesh/model/UpgradeMeshVersionResult.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_SERVICEMESH_MODEL_UPGRADEMESHVERSIONRESULT_H_
+#define ALIBABACLOUD_SERVICEMESH_MODEL_UPGRADEMESHVERSIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/servicemesh/ServicemeshExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Servicemesh
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SERVICEMESH_EXPORT UpgradeMeshVersionResult : public ServiceResult
+			{
+			public:
+
+
+				UpgradeMeshVersionResult();
+				explicit UpgradeMeshVersionResult(const std::string &payload);
+				~UpgradeMeshVersionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SERVICEMESH_MODEL_UPGRADEMESHVERSIONRESULT_H_

servicemesh/src/ServicemeshClient.cc

@@ -0,0 +1,1025 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/ServicemeshClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Servicemesh;
+using namespace AlibabaCloud::Servicemesh::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "servicemesh";
+}
+
+ServicemeshClient::ServicemeshClient(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, "servicemesh");
+}
+
+ServicemeshClient::ServicemeshClient(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, "servicemesh");
+}
+
+ServicemeshClient::ServicemeshClient(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, "servicemesh");
+}
+
+ServicemeshClient::~ServicemeshClient()
+{}
+
+ServicemeshClient::AddClusterIntoServiceMeshOutcome ServicemeshClient::addClusterIntoServiceMesh(const AddClusterIntoServiceMeshRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddClusterIntoServiceMeshOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddClusterIntoServiceMeshOutcome(AddClusterIntoServiceMeshResult(outcome.result()));
+	else
+		return AddClusterIntoServiceMeshOutcome(outcome.error());
+}
+
+void ServicemeshClient::addClusterIntoServiceMeshAsync(const AddClusterIntoServiceMeshRequest& request, const AddClusterIntoServiceMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addClusterIntoServiceMesh(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::AddClusterIntoServiceMeshOutcomeCallable ServicemeshClient::addClusterIntoServiceMeshCallable(const AddClusterIntoServiceMeshRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddClusterIntoServiceMeshOutcome()>>(
+			[this, request]()
+			{
+			return this->addClusterIntoServiceMesh(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::AddVmAppToMeshOutcome ServicemeshClient::addVmAppToMesh(const AddVmAppToMeshRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddVmAppToMeshOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddVmAppToMeshOutcome(AddVmAppToMeshResult(outcome.result()));
+	else
+		return AddVmAppToMeshOutcome(outcome.error());
+}
+
+void ServicemeshClient::addVmAppToMeshAsync(const AddVmAppToMeshRequest& request, const AddVmAppToMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addVmAppToMesh(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::AddVmAppToMeshOutcomeCallable ServicemeshClient::addVmAppToMeshCallable(const AddVmAppToMeshRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddVmAppToMeshOutcome()>>(
+			[this, request]()
+			{
+			return this->addVmAppToMesh(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::CreateServiceMeshOutcome ServicemeshClient::createServiceMesh(const CreateServiceMeshRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateServiceMeshOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateServiceMeshOutcome(CreateServiceMeshResult(outcome.result()));
+	else
+		return CreateServiceMeshOutcome(outcome.error());
+}
+
+void ServicemeshClient::createServiceMeshAsync(const CreateServiceMeshRequest& request, const CreateServiceMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createServiceMesh(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::CreateServiceMeshOutcomeCallable ServicemeshClient::createServiceMeshCallable(const CreateServiceMeshRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateServiceMeshOutcome()>>(
+			[this, request]()
+			{
+			return this->createServiceMesh(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::DeleteServiceMeshOutcome ServicemeshClient::deleteServiceMesh(const DeleteServiceMeshRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteServiceMeshOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteServiceMeshOutcome(DeleteServiceMeshResult(outcome.result()));
+	else
+		return DeleteServiceMeshOutcome(outcome.error());
+}
+
+void ServicemeshClient::deleteServiceMeshAsync(const DeleteServiceMeshRequest& request, const DeleteServiceMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteServiceMesh(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::DeleteServiceMeshOutcomeCallable ServicemeshClient::deleteServiceMeshCallable(const DeleteServiceMeshRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteServiceMeshOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteServiceMesh(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::DescribeCensOutcome ServicemeshClient::describeCens(const DescribeCensRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeCensOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeCensOutcome(DescribeCensResult(outcome.result()));
+	else
+		return DescribeCensOutcome(outcome.error());
+}
+
+void ServicemeshClient::describeCensAsync(const DescribeCensRequest& request, const DescribeCensAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeCens(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::DescribeCensOutcomeCallable ServicemeshClient::describeCensCallable(const DescribeCensRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeCensOutcome()>>(
+			[this, request]()
+			{
+			return this->describeCens(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::DescribeClusterGrafanaOutcome ServicemeshClient::describeClusterGrafana(const DescribeClusterGrafanaRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeClusterGrafanaOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeClusterGrafanaOutcome(DescribeClusterGrafanaResult(outcome.result()));
+	else
+		return DescribeClusterGrafanaOutcome(outcome.error());
+}
+
+void ServicemeshClient::describeClusterGrafanaAsync(const DescribeClusterGrafanaRequest& request, const DescribeClusterGrafanaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeClusterGrafana(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::DescribeClusterGrafanaOutcomeCallable ServicemeshClient::describeClusterGrafanaCallable(const DescribeClusterGrafanaRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeClusterGrafanaOutcome()>>(
+			[this, request]()
+			{
+			return this->describeClusterGrafana(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::DescribeClusterPrometheusOutcome ServicemeshClient::describeClusterPrometheus(const DescribeClusterPrometheusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeClusterPrometheusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeClusterPrometheusOutcome(DescribeClusterPrometheusResult(outcome.result()));
+	else
+		return DescribeClusterPrometheusOutcome(outcome.error());
+}
+
+void ServicemeshClient::describeClusterPrometheusAsync(const DescribeClusterPrometheusRequest& request, const DescribeClusterPrometheusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeClusterPrometheus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::DescribeClusterPrometheusOutcomeCallable ServicemeshClient::describeClusterPrometheusCallable(const DescribeClusterPrometheusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeClusterPrometheusOutcome()>>(
+			[this, request]()
+			{
+			return this->describeClusterPrometheus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::DescribeClustersInServiceMeshOutcome ServicemeshClient::describeClustersInServiceMesh(const DescribeClustersInServiceMeshRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeClustersInServiceMeshOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeClustersInServiceMeshOutcome(DescribeClustersInServiceMeshResult(outcome.result()));
+	else
+		return DescribeClustersInServiceMeshOutcome(outcome.error());
+}
+
+void ServicemeshClient::describeClustersInServiceMeshAsync(const DescribeClustersInServiceMeshRequest& request, const DescribeClustersInServiceMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeClustersInServiceMesh(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::DescribeClustersInServiceMeshOutcomeCallable ServicemeshClient::describeClustersInServiceMeshCallable(const DescribeClustersInServiceMeshRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeClustersInServiceMeshOutcome()>>(
+			[this, request]()
+			{
+			return this->describeClustersInServiceMesh(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::DescribeGuestClusterAccessLogDashboardsOutcome ServicemeshClient::describeGuestClusterAccessLogDashboards(const DescribeGuestClusterAccessLogDashboardsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeGuestClusterAccessLogDashboardsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeGuestClusterAccessLogDashboardsOutcome(DescribeGuestClusterAccessLogDashboardsResult(outcome.result()));
+	else
+		return DescribeGuestClusterAccessLogDashboardsOutcome(outcome.error());
+}
+
+void ServicemeshClient::describeGuestClusterAccessLogDashboardsAsync(const DescribeGuestClusterAccessLogDashboardsRequest& request, const DescribeGuestClusterAccessLogDashboardsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeGuestClusterAccessLogDashboards(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::DescribeGuestClusterAccessLogDashboardsOutcomeCallable ServicemeshClient::describeGuestClusterAccessLogDashboardsCallable(const DescribeGuestClusterAccessLogDashboardsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeGuestClusterAccessLogDashboardsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeGuestClusterAccessLogDashboards(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::DescribeIngressGatewaysOutcome ServicemeshClient::describeIngressGateways(const DescribeIngressGatewaysRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeIngressGatewaysOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeIngressGatewaysOutcome(DescribeIngressGatewaysResult(outcome.result()));
+	else
+		return DescribeIngressGatewaysOutcome(outcome.error());
+}
+
+void ServicemeshClient::describeIngressGatewaysAsync(const DescribeIngressGatewaysRequest& request, const DescribeIngressGatewaysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeIngressGateways(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::DescribeIngressGatewaysOutcomeCallable ServicemeshClient::describeIngressGatewaysCallable(const DescribeIngressGatewaysRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeIngressGatewaysOutcome()>>(
+			[this, request]()
+			{
+			return this->describeIngressGateways(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::DescribeServiceMeshDetailOutcome ServicemeshClient::describeServiceMeshDetail(const DescribeServiceMeshDetailRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeServiceMeshDetailOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeServiceMeshDetailOutcome(DescribeServiceMeshDetailResult(outcome.result()));
+	else
+		return DescribeServiceMeshDetailOutcome(outcome.error());
+}
+
+void ServicemeshClient::describeServiceMeshDetailAsync(const DescribeServiceMeshDetailRequest& request, const DescribeServiceMeshDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeServiceMeshDetail(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::DescribeServiceMeshDetailOutcomeCallable ServicemeshClient::describeServiceMeshDetailCallable(const DescribeServiceMeshDetailRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeServiceMeshDetailOutcome()>>(
+			[this, request]()
+			{
+			return this->describeServiceMeshDetail(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::DescribeServiceMeshKubeconfigOutcome ServicemeshClient::describeServiceMeshKubeconfig(const DescribeServiceMeshKubeconfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeServiceMeshKubeconfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeServiceMeshKubeconfigOutcome(DescribeServiceMeshKubeconfigResult(outcome.result()));
+	else
+		return DescribeServiceMeshKubeconfigOutcome(outcome.error());
+}
+
+void ServicemeshClient::describeServiceMeshKubeconfigAsync(const DescribeServiceMeshKubeconfigRequest& request, const DescribeServiceMeshKubeconfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeServiceMeshKubeconfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::DescribeServiceMeshKubeconfigOutcomeCallable ServicemeshClient::describeServiceMeshKubeconfigCallable(const DescribeServiceMeshKubeconfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeServiceMeshKubeconfigOutcome()>>(
+			[this, request]()
+			{
+			return this->describeServiceMeshKubeconfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::DescribeServiceMeshesOutcome ServicemeshClient::describeServiceMeshes(const DescribeServiceMeshesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeServiceMeshesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeServiceMeshesOutcome(DescribeServiceMeshesResult(outcome.result()));
+	else
+		return DescribeServiceMeshesOutcome(outcome.error());
+}
+
+void ServicemeshClient::describeServiceMeshesAsync(const DescribeServiceMeshesRequest& request, const DescribeServiceMeshesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeServiceMeshes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::DescribeServiceMeshesOutcomeCallable ServicemeshClient::describeServiceMeshesCallable(const DescribeServiceMeshesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeServiceMeshesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeServiceMeshes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::DescribeUpgradeVersionOutcome ServicemeshClient::describeUpgradeVersion(const DescribeUpgradeVersionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeUpgradeVersionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeUpgradeVersionOutcome(DescribeUpgradeVersionResult(outcome.result()));
+	else
+		return DescribeUpgradeVersionOutcome(outcome.error());
+}
+
+void ServicemeshClient::describeUpgradeVersionAsync(const DescribeUpgradeVersionRequest& request, const DescribeUpgradeVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeUpgradeVersion(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::DescribeUpgradeVersionOutcomeCallable ServicemeshClient::describeUpgradeVersionCallable(const DescribeUpgradeVersionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeUpgradeVersionOutcome()>>(
+			[this, request]()
+			{
+			return this->describeUpgradeVersion(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::GetDiagnosisOutcome ServicemeshClient::getDiagnosis(const GetDiagnosisRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetDiagnosisOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetDiagnosisOutcome(GetDiagnosisResult(outcome.result()));
+	else
+		return GetDiagnosisOutcome(outcome.error());
+}
+
+void ServicemeshClient::getDiagnosisAsync(const GetDiagnosisRequest& request, const GetDiagnosisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getDiagnosis(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::GetDiagnosisOutcomeCallable ServicemeshClient::getDiagnosisCallable(const GetDiagnosisRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetDiagnosisOutcome()>>(
+			[this, request]()
+			{
+			return this->getDiagnosis(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::GetRegisteredServiceEndpointsOutcome ServicemeshClient::getRegisteredServiceEndpoints(const GetRegisteredServiceEndpointsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetRegisteredServiceEndpointsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetRegisteredServiceEndpointsOutcome(GetRegisteredServiceEndpointsResult(outcome.result()));
+	else
+		return GetRegisteredServiceEndpointsOutcome(outcome.error());
+}
+
+void ServicemeshClient::getRegisteredServiceEndpointsAsync(const GetRegisteredServiceEndpointsRequest& request, const GetRegisteredServiceEndpointsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getRegisteredServiceEndpoints(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::GetRegisteredServiceEndpointsOutcomeCallable ServicemeshClient::getRegisteredServiceEndpointsCallable(const GetRegisteredServiceEndpointsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetRegisteredServiceEndpointsOutcome()>>(
+			[this, request]()
+			{
+			return this->getRegisteredServiceEndpoints(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::GetRegisteredServiceNamespacesOutcome ServicemeshClient::getRegisteredServiceNamespaces(const GetRegisteredServiceNamespacesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetRegisteredServiceNamespacesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetRegisteredServiceNamespacesOutcome(GetRegisteredServiceNamespacesResult(outcome.result()));
+	else
+		return GetRegisteredServiceNamespacesOutcome(outcome.error());
+}
+
+void ServicemeshClient::getRegisteredServiceNamespacesAsync(const GetRegisteredServiceNamespacesRequest& request, const GetRegisteredServiceNamespacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getRegisteredServiceNamespaces(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::GetRegisteredServiceNamespacesOutcomeCallable ServicemeshClient::getRegisteredServiceNamespacesCallable(const GetRegisteredServiceNamespacesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetRegisteredServiceNamespacesOutcome()>>(
+			[this, request]()
+			{
+			return this->getRegisteredServiceNamespaces(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::GetRegisteredServicesOutcome ServicemeshClient::getRegisteredServices(const GetRegisteredServicesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetRegisteredServicesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetRegisteredServicesOutcome(GetRegisteredServicesResult(outcome.result()));
+	else
+		return GetRegisteredServicesOutcome(outcome.error());
+}
+
+void ServicemeshClient::getRegisteredServicesAsync(const GetRegisteredServicesRequest& request, const GetRegisteredServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getRegisteredServices(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::GetRegisteredServicesOutcomeCallable ServicemeshClient::getRegisteredServicesCallable(const GetRegisteredServicesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetRegisteredServicesOutcome()>>(
+			[this, request]()
+			{
+			return this->getRegisteredServices(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::GetServiceMeshSlbOutcome ServicemeshClient::getServiceMeshSlb(const GetServiceMeshSlbRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetServiceMeshSlbOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetServiceMeshSlbOutcome(GetServiceMeshSlbResult(outcome.result()));
+	else
+		return GetServiceMeshSlbOutcome(outcome.error());
+}
+
+void ServicemeshClient::getServiceMeshSlbAsync(const GetServiceMeshSlbRequest& request, const GetServiceMeshSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getServiceMeshSlb(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::GetServiceMeshSlbOutcomeCallable ServicemeshClient::getServiceMeshSlbCallable(const GetServiceMeshSlbRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetServiceMeshSlbOutcome()>>(
+			[this, request]()
+			{
+			return this->getServiceMeshSlb(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::GetVmAppMeshInfoOutcome ServicemeshClient::getVmAppMeshInfo(const GetVmAppMeshInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetVmAppMeshInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetVmAppMeshInfoOutcome(GetVmAppMeshInfoResult(outcome.result()));
+	else
+		return GetVmAppMeshInfoOutcome(outcome.error());
+}
+
+void ServicemeshClient::getVmAppMeshInfoAsync(const GetVmAppMeshInfoRequest& request, const GetVmAppMeshInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getVmAppMeshInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::GetVmAppMeshInfoOutcomeCallable ServicemeshClient::getVmAppMeshInfoCallable(const GetVmAppMeshInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetVmAppMeshInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->getVmAppMeshInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::GetVmMetaOutcome ServicemeshClient::getVmMeta(const GetVmMetaRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetVmMetaOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetVmMetaOutcome(GetVmMetaResult(outcome.result()));
+	else
+		return GetVmMetaOutcome(outcome.error());
+}
+
+void ServicemeshClient::getVmMetaAsync(const GetVmMetaRequest& request, const GetVmMetaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getVmMeta(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::GetVmMetaOutcomeCallable ServicemeshClient::getVmMetaCallable(const GetVmMetaRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetVmMetaOutcome()>>(
+			[this, request]()
+			{
+			return this->getVmMeta(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::RemoveClusterFromServiceMeshOutcome ServicemeshClient::removeClusterFromServiceMesh(const RemoveClusterFromServiceMeshRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RemoveClusterFromServiceMeshOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RemoveClusterFromServiceMeshOutcome(RemoveClusterFromServiceMeshResult(outcome.result()));
+	else
+		return RemoveClusterFromServiceMeshOutcome(outcome.error());
+}
+
+void ServicemeshClient::removeClusterFromServiceMeshAsync(const RemoveClusterFromServiceMeshRequest& request, const RemoveClusterFromServiceMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, removeClusterFromServiceMesh(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::RemoveClusterFromServiceMeshOutcomeCallable ServicemeshClient::removeClusterFromServiceMeshCallable(const RemoveClusterFromServiceMeshRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RemoveClusterFromServiceMeshOutcome()>>(
+			[this, request]()
+			{
+			return this->removeClusterFromServiceMesh(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::RemoveVmAppFromMeshOutcome ServicemeshClient::removeVmAppFromMesh(const RemoveVmAppFromMeshRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RemoveVmAppFromMeshOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RemoveVmAppFromMeshOutcome(RemoveVmAppFromMeshResult(outcome.result()));
+	else
+		return RemoveVmAppFromMeshOutcome(outcome.error());
+}
+
+void ServicemeshClient::removeVmAppFromMeshAsync(const RemoveVmAppFromMeshRequest& request, const RemoveVmAppFromMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, removeVmAppFromMesh(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::RemoveVmAppFromMeshOutcomeCallable ServicemeshClient::removeVmAppFromMeshCallable(const RemoveVmAppFromMeshRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RemoveVmAppFromMeshOutcome()>>(
+			[this, request]()
+			{
+			return this->removeVmAppFromMesh(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::RunDiagnosisOutcome ServicemeshClient::runDiagnosis(const RunDiagnosisRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RunDiagnosisOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RunDiagnosisOutcome(RunDiagnosisResult(outcome.result()));
+	else
+		return RunDiagnosisOutcome(outcome.error());
+}
+
+void ServicemeshClient::runDiagnosisAsync(const RunDiagnosisRequest& request, const RunDiagnosisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, runDiagnosis(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::RunDiagnosisOutcomeCallable ServicemeshClient::runDiagnosisCallable(const RunDiagnosisRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RunDiagnosisOutcome()>>(
+			[this, request]()
+			{
+			return this->runDiagnosis(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::UpdateIstioInjectionConfigOutcome ServicemeshClient::updateIstioInjectionConfig(const UpdateIstioInjectionConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateIstioInjectionConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateIstioInjectionConfigOutcome(UpdateIstioInjectionConfigResult(outcome.result()));
+	else
+		return UpdateIstioInjectionConfigOutcome(outcome.error());
+}
+
+void ServicemeshClient::updateIstioInjectionConfigAsync(const UpdateIstioInjectionConfigRequest& request, const UpdateIstioInjectionConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateIstioInjectionConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::UpdateIstioInjectionConfigOutcomeCallable ServicemeshClient::updateIstioInjectionConfigCallable(const UpdateIstioInjectionConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateIstioInjectionConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->updateIstioInjectionConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::UpdateMeshFeatureOutcome ServicemeshClient::updateMeshFeature(const UpdateMeshFeatureRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateMeshFeatureOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateMeshFeatureOutcome(UpdateMeshFeatureResult(outcome.result()));
+	else
+		return UpdateMeshFeatureOutcome(outcome.error());
+}
+
+void ServicemeshClient::updateMeshFeatureAsync(const UpdateMeshFeatureRequest& request, const UpdateMeshFeatureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateMeshFeature(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::UpdateMeshFeatureOutcomeCallable ServicemeshClient::updateMeshFeatureCallable(const UpdateMeshFeatureRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateMeshFeatureOutcome()>>(
+			[this, request]()
+			{
+			return this->updateMeshFeature(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ServicemeshClient::UpgradeMeshVersionOutcome ServicemeshClient::upgradeMeshVersion(const UpgradeMeshVersionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpgradeMeshVersionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpgradeMeshVersionOutcome(UpgradeMeshVersionResult(outcome.result()));
+	else
+		return UpgradeMeshVersionOutcome(outcome.error());
+}
+
+void ServicemeshClient::upgradeMeshVersionAsync(const UpgradeMeshVersionRequest& request, const UpgradeMeshVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, upgradeMeshVersion(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ServicemeshClient::UpgradeMeshVersionOutcomeCallable ServicemeshClient::upgradeMeshVersionCallable(const UpgradeMeshVersionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpgradeMeshVersionOutcome()>>(
+			[this, request]()
+			{
+			return this->upgradeMeshVersion(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

servicemesh/src/model/AddClusterIntoServiceMeshRequest.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/servicemesh/model/AddClusterIntoServiceMeshRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::AddClusterIntoServiceMeshRequest;
+
+AddClusterIntoServiceMeshRequest::AddClusterIntoServiceMeshRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "AddClusterIntoServiceMesh")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddClusterIntoServiceMeshRequest::~AddClusterIntoServiceMeshRequest()
+{}
+
+std::string AddClusterIntoServiceMeshRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void AddClusterIntoServiceMeshRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setBodyParameter("ClusterId", clusterId);
+}
+
+std::string AddClusterIntoServiceMeshRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void AddClusterIntoServiceMeshRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setBodyParameter("ServiceMeshId", serviceMeshId);
+}
+

servicemesh/src/model/AddClusterIntoServiceMeshResult.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/servicemesh/model/AddClusterIntoServiceMeshResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Servicemesh;
+using namespace AlibabaCloud::Servicemesh::Model;
+
+AddClusterIntoServiceMeshResult::AddClusterIntoServiceMeshResult() :
+	ServiceResult()
+{}
+
+AddClusterIntoServiceMeshResult::AddClusterIntoServiceMeshResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddClusterIntoServiceMeshResult::~AddClusterIntoServiceMeshResult()
+{}
+
+void AddClusterIntoServiceMeshResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string AddClusterIntoServiceMeshResult::getMessage()const
+{
+	return message_;
+}
+
+std::string AddClusterIntoServiceMeshResult::getCode()const
+{
+	return code_;
+}
+

servicemesh/src/model/AddVmAppToMeshRequest.cc

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/AddVmAppToMeshRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::AddVmAppToMeshRequest;
+
+AddVmAppToMeshRequest::AddVmAppToMeshRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "AddVmAppToMesh")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddVmAppToMeshRequest::~AddVmAppToMeshRequest()
+{}
+
+std::string AddVmAppToMeshRequest::getServiceAccount()const
+{
+	return serviceAccount_;
+}
+
+void AddVmAppToMeshRequest::setServiceAccount(const std::string& serviceAccount)
+{
+	serviceAccount_ = serviceAccount;
+	setParameter("ServiceAccount", serviceAccount);
+}
+
+std::string AddVmAppToMeshRequest::getAnnotations()const
+{
+	return annotations_;
+}
+
+void AddVmAppToMeshRequest::setAnnotations(const std::string& annotations)
+{
+	annotations_ = annotations;
+	setParameter("Annotations", annotations);
+}
+
+std::string AddVmAppToMeshRequest::getPorts()const
+{
+	return ports_;
+}
+
+void AddVmAppToMeshRequest::setPorts(const std::string& ports)
+{
+	ports_ = ports;
+	setParameter("Ports", ports);
+}
+
+std::string AddVmAppToMeshRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void AddVmAppToMeshRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setParameter("ServiceMeshId", serviceMeshId);
+}
+
+std::string AddVmAppToMeshRequest::getServiceName()const
+{
+	return serviceName_;
+}
+
+void AddVmAppToMeshRequest::setServiceName(const std::string& serviceName)
+{
+	serviceName_ = serviceName;
+	setParameter("ServiceName", serviceName);
+}
+
+bool AddVmAppToMeshRequest::getUseWorkload()const
+{
+	return useWorkload_;
+}
+
+void AddVmAppToMeshRequest::setUseWorkload(bool useWorkload)
+{
+	useWorkload_ = useWorkload;
+	setParameter("UseWorkload", useWorkload ? "true" : "false");
+}
+
+std::string AddVmAppToMeshRequest::getIps()const
+{
+	return ips_;
+}
+
+void AddVmAppToMeshRequest::setIps(const std::string& ips)
+{
+	ips_ = ips;
+	setParameter("Ips", ips);
+}
+
+std::string AddVmAppToMeshRequest::getLabels()const
+{
+	return labels_;
+}
+
+void AddVmAppToMeshRequest::setLabels(const std::string& labels)
+{
+	labels_ = labels;
+	setParameter("Labels", labels);
+}
+
+std::string AddVmAppToMeshRequest::get_Namespace()const
+{
+	return _namespace_;
+}
+
+void AddVmAppToMeshRequest::set_Namespace(const std::string& _namespace)
+{
+	_namespace_ = _namespace;
+	setParameter("_Namespace", _namespace);
+}
+
+bool AddVmAppToMeshRequest::getForce()const
+{
+	return force_;
+}
+
+void AddVmAppToMeshRequest::setForce(bool force)
+{
+	force_ = force;
+	setParameter("Force", force ? "true" : "false");
+}
+

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

servicemesh/src/model/CreateServiceMeshRequest.cc

@@ -0,0 +1,403 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/CreateServiceMeshRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::CreateServiceMeshRequest;
+
+CreateServiceMeshRequest::CreateServiceMeshRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "CreateServiceMesh")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateServiceMeshRequest::~CreateServiceMeshRequest()
+{}
+
+std::string CreateServiceMeshRequest::getProxyRequestCPU()const
+{
+	return proxyRequestCPU_;
+}
+
+void CreateServiceMeshRequest::setProxyRequestCPU(const std::string& proxyRequestCPU)
+{
+	proxyRequestCPU_ = proxyRequestCPU;
+	setBodyParameter("ProxyRequestCPU", proxyRequestCPU);
+}
+
+std::string CreateServiceMeshRequest::getOPALimitCPU()const
+{
+	return oPALimitCPU_;
+}
+
+void CreateServiceMeshRequest::setOPALimitCPU(const std::string& oPALimitCPU)
+{
+	oPALimitCPU_ = oPALimitCPU;
+	setBodyParameter("OPALimitCPU", oPALimitCPU);
+}
+
+bool CreateServiceMeshRequest::getOpenAgentPolicy()const
+{
+	return openAgentPolicy_;
+}
+
+void CreateServiceMeshRequest::setOpenAgentPolicy(bool openAgentPolicy)
+{
+	openAgentPolicy_ = openAgentPolicy;
+	setBodyParameter("OpenAgentPolicy", openAgentPolicy ? "true" : "false");
+}
+
+bool CreateServiceMeshRequest::getOpaEnabled()const
+{
+	return opaEnabled_;
+}
+
+void CreateServiceMeshRequest::setOpaEnabled(bool opaEnabled)
+{
+	opaEnabled_ = opaEnabled;
+	setBodyParameter("OpaEnabled", opaEnabled ? "true" : "false");
+}
+
+std::string CreateServiceMeshRequest::getProxyLimitMemory()const
+{
+	return proxyLimitMemory_;
+}
+
+void CreateServiceMeshRequest::setProxyLimitMemory(const std::string& proxyLimitMemory)
+{
+	proxyLimitMemory_ = proxyLimitMemory;
+	setBodyParameter("ProxyLimitMemory", proxyLimitMemory);
+}
+
+bool CreateServiceMeshRequest::getStrictMTLS()const
+{
+	return strictMTLS_;
+}
+
+void CreateServiceMeshRequest::setStrictMTLS(bool strictMTLS)
+{
+	strictMTLS_ = strictMTLS;
+	setBodyParameter("StrictMTLS", strictMTLS ? "true" : "false");
+}
+
+std::string CreateServiceMeshRequest::getOPALogLevel()const
+{
+	return oPALogLevel_;
+}
+
+void CreateServiceMeshRequest::setOPALogLevel(const std::string& oPALogLevel)
+{
+	oPALogLevel_ = oPALogLevel;
+	setBodyParameter("OPALogLevel", oPALogLevel);
+}
+
+std::string CreateServiceMeshRequest::getExcludeIPRanges()const
+{
+	return excludeIPRanges_;
+}
+
+void CreateServiceMeshRequest::setExcludeIPRanges(const std::string& excludeIPRanges)
+{
+	excludeIPRanges_ = excludeIPRanges;
+	setBodyParameter("ExcludeIPRanges", excludeIPRanges);
+}
+
+std::string CreateServiceMeshRequest::getIstioVersion()const
+{
+	return istioVersion_;
+}
+
+void CreateServiceMeshRequest::setIstioVersion(const std::string& istioVersion)
+{
+	istioVersion_ = istioVersion;
+	setBodyParameter("IstioVersion", istioVersion);
+}
+
+bool CreateServiceMeshRequest::getTracing()const
+{
+	return tracing_;
+}
+
+void CreateServiceMeshRequest::setTracing(bool tracing)
+{
+	tracing_ = tracing;
+	setBodyParameter("Tracing", tracing ? "true" : "false");
+}
+
+std::string CreateServiceMeshRequest::getIncludeIPRanges()const
+{
+	return includeIPRanges_;
+}
+
+void CreateServiceMeshRequest::setIncludeIPRanges(const std::string& includeIPRanges)
+{
+	includeIPRanges_ = includeIPRanges;
+	setBodyParameter("IncludeIPRanges", includeIPRanges);
+}
+
+std::string CreateServiceMeshRequest::getExcludeInboundPorts()const
+{
+	return excludeInboundPorts_;
+}
+
+void CreateServiceMeshRequest::setExcludeInboundPorts(const std::string& excludeInboundPorts)
+{
+	excludeInboundPorts_ = excludeInboundPorts;
+	setBodyParameter("ExcludeInboundPorts", excludeInboundPorts);
+}
+
+std::string CreateServiceMeshRequest::getOPALimitMemory()const
+{
+	return oPALimitMemory_;
+}
+
+void CreateServiceMeshRequest::setOPALimitMemory(const std::string& oPALimitMemory)
+{
+	oPALimitMemory_ = oPALimitMemory;
+	setBodyParameter("OPALimitMemory", oPALimitMemory);
+}
+
+std::string CreateServiceMeshRequest::getVSwitches()const
+{
+	return vSwitches_;
+}
+
+void CreateServiceMeshRequest::setVSwitches(const std::string& vSwitches)
+{
+	vSwitches_ = vSwitches;
+	setBodyParameter("VSwitches", vSwitches);
+}
+
+bool CreateServiceMeshRequest::getCADisableSecretAutoGeneration()const
+{
+	return cADisableSecretAutoGeneration_;
+}
+
+void CreateServiceMeshRequest::setCADisableSecretAutoGeneration(bool cADisableSecretAutoGeneration)
+{
+	cADisableSecretAutoGeneration_ = cADisableSecretAutoGeneration;
+	setBodyParameter("CADisableSecretAutoGeneration", cADisableSecretAutoGeneration ? "true" : "false");
+}
+
+std::string CreateServiceMeshRequest::getCAListenedNamespaces()const
+{
+	return cAListenedNamespaces_;
+}
+
+void CreateServiceMeshRequest::setCAListenedNamespaces(const std::string& cAListenedNamespaces)
+{
+	cAListenedNamespaces_ = cAListenedNamespaces;
+	setBodyParameter("CAListenedNamespaces", cAListenedNamespaces);
+}
+
+std::string CreateServiceMeshRequest::getProxyLimitCPU()const
+{
+	return proxyLimitCPU_;
+}
+
+void CreateServiceMeshRequest::setProxyLimitCPU(const std::string& proxyLimitCPU)
+{
+	proxyLimitCPU_ = proxyLimitCPU;
+	setBodyParameter("ProxyLimitCPU", proxyLimitCPU);
+}
+
+std::string CreateServiceMeshRequest::getProxyRequestMemory()const
+{
+	return proxyRequestMemory_;
+}
+
+void CreateServiceMeshRequest::setProxyRequestMemory(const std::string& proxyRequestMemory)
+{
+	proxyRequestMemory_ = proxyRequestMemory;
+	setBodyParameter("ProxyRequestMemory", proxyRequestMemory);
+}
+
+std::string CreateServiceMeshRequest::getName()const
+{
+	return name_;
+}
+
+void CreateServiceMeshRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setBodyParameter("Name", name);
+}
+
+bool CreateServiceMeshRequest::getTelemetry()const
+{
+	return telemetry_;
+}
+
+void CreateServiceMeshRequest::setTelemetry(bool telemetry)
+{
+	telemetry_ = telemetry;
+	setBodyParameter("Telemetry", telemetry ? "true" : "false");
+}
+
+std::string CreateServiceMeshRequest::getOPARequestCPU()const
+{
+	return oPARequestCPU_;
+}
+
+void CreateServiceMeshRequest::setOPARequestCPU(const std::string& oPARequestCPU)
+{
+	oPARequestCPU_ = oPARequestCPU;
+	setBodyParameter("OPARequestCPU", oPARequestCPU);
+}
+
+std::string CreateServiceMeshRequest::getOPARequestMemory()const
+{
+	return oPARequestMemory_;
+}
+
+void CreateServiceMeshRequest::setOPARequestMemory(const std::string& oPARequestMemory)
+{
+	oPARequestMemory_ = oPARequestMemory;
+	setBodyParameter("OPARequestMemory", oPARequestMemory);
+}
+
+bool CreateServiceMeshRequest::getEnableAudit()const
+{
+	return enableAudit_;
+}
+
+void CreateServiceMeshRequest::setEnableAudit(bool enableAudit)
+{
+	enableAudit_ = enableAudit;
+	setBodyParameter("EnableAudit", enableAudit ? "true" : "false");
+}
+
+std::string CreateServiceMeshRequest::getClusterDomain()const
+{
+	return clusterDomain_;
+}
+
+void CreateServiceMeshRequest::setClusterDomain(const std::string& clusterDomain)
+{
+	clusterDomain_ = clusterDomain;
+	setBodyParameter("ClusterDomain", clusterDomain);
+}
+
+std::string CreateServiceMeshRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateServiceMeshRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setBodyParameter("RegionId", regionId);
+}
+
+bool CreateServiceMeshRequest::getLocalityLoadBalancing()const
+{
+	return localityLoadBalancing_;
+}
+
+void CreateServiceMeshRequest::setLocalityLoadBalancing(bool localityLoadBalancing)
+{
+	localityLoadBalancing_ = localityLoadBalancing;
+	setBodyParameter("LocalityLoadBalancing", localityLoadBalancing ? "true" : "false");
+}
+
+bool CreateServiceMeshRequest::getApiServerPublicEip()const
+{
+	return apiServerPublicEip_;
+}
+
+void CreateServiceMeshRequest::setApiServerPublicEip(bool apiServerPublicEip)
+{
+	apiServerPublicEip_ = apiServerPublicEip;
+	setBodyParameter("ApiServerPublicEip", apiServerPublicEip ? "true" : "false");
+}
+
+float CreateServiceMeshRequest::getTraceSampling()const
+{
+	return traceSampling_;
+}
+
+void CreateServiceMeshRequest::setTraceSampling(float traceSampling)
+{
+	traceSampling_ = traceSampling;
+	setBodyParameter("TraceSampling", std::to_string(traceSampling));
+}
+
+std::string CreateServiceMeshRequest::getAppNamespaces()const
+{
+	return appNamespaces_;
+}
+
+void CreateServiceMeshRequest::setAppNamespaces(const std::string& appNamespaces)
+{
+	appNamespaces_ = appNamespaces;
+	setBodyParameter("AppNamespaces", appNamespaces);
+}
+
+bool CreateServiceMeshRequest::getPilotPublicEip()const
+{
+	return pilotPublicEip_;
+}
+
+void CreateServiceMeshRequest::setPilotPublicEip(bool pilotPublicEip)
+{
+	pilotPublicEip_ = pilotPublicEip;
+	setBodyParameter("PilotPublicEip", pilotPublicEip ? "true" : "false");
+}
+
+std::string CreateServiceMeshRequest::getAuditProject()const
+{
+	return auditProject_;
+}
+
+void CreateServiceMeshRequest::setAuditProject(const std::string& auditProject)
+{
+	auditProject_ = auditProject;
+	setBodyParameter("AuditProject", auditProject);
+}
+
+std::string CreateServiceMeshRequest::getOutboundTrafficPolicy()const
+{
+	return outboundTrafficPolicy_;
+}
+
+void CreateServiceMeshRequest::setOutboundTrafficPolicy(const std::string& outboundTrafficPolicy)
+{
+	outboundTrafficPolicy_ = outboundTrafficPolicy;
+	setBodyParameter("OutboundTrafficPolicy", outboundTrafficPolicy);
+}
+
+std::string CreateServiceMeshRequest::getVpcId()const
+{
+	return vpcId_;
+}
+
+void CreateServiceMeshRequest::setVpcId(const std::string& vpcId)
+{
+	vpcId_ = vpcId;
+	setBodyParameter("VpcId", vpcId);
+}
+
+std::string CreateServiceMeshRequest::getExcludeOutboundPorts()const
+{
+	return excludeOutboundPorts_;
+}
+
+void CreateServiceMeshRequest::setExcludeOutboundPorts(const std::string& excludeOutboundPorts)
+{
+	excludeOutboundPorts_ = excludeOutboundPorts;
+	setBodyParameter("ExcludeOutboundPorts", excludeOutboundPorts);
+}
+

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

servicemesh/src/model/DeleteServiceMeshRequest.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/servicemesh/model/DeleteServiceMeshRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::DeleteServiceMeshRequest;
+
+DeleteServiceMeshRequest::DeleteServiceMeshRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "DeleteServiceMesh")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteServiceMeshRequest::~DeleteServiceMeshRequest()
+{}
+
+std::string DeleteServiceMeshRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void DeleteServiceMeshRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setBodyParameter("ServiceMeshId", serviceMeshId);
+}
+
+bool DeleteServiceMeshRequest::getForce()const
+{
+	return force_;
+}
+
+void DeleteServiceMeshRequest::setForce(bool force)
+{
+	force_ = force;
+	setBodyParameter("Force", force ? "true" : "false");
+}
+

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

servicemesh/src/model/DescribeCensRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/DescribeCensRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::DescribeCensRequest;
+
+DescribeCensRequest::DescribeCensRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "DescribeCens")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeCensRequest::~DescribeCensRequest()
+{}
+
+std::string DescribeCensRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void DescribeCensRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setParameter("ServiceMeshId", serviceMeshId);
+}
+

servicemesh/src/model/DescribeCensResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/servicemesh/model/DescribeCensResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Servicemesh;
+using namespace AlibabaCloud::Servicemesh::Model;
+
+DescribeCensResult::DescribeCensResult() :
+	ServiceResult()
+{}
+
+DescribeCensResult::DescribeCensResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeCensResult::~DescribeCensResult()
+{}
+
+void DescribeCensResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allClusters = value["Clusters"]["Cluster"];
+	for (const auto &item : allClusters)
+		clusters_.push_back(item.asString());
+
+}
+
+std::vector<std::string> DescribeCensResult::getClusters()const
+{
+	return clusters_;
+}
+

servicemesh/src/model/DescribeClusterGrafanaRequest.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/servicemesh/model/DescribeClusterGrafanaRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::DescribeClusterGrafanaRequest;
+
+DescribeClusterGrafanaRequest::DescribeClusterGrafanaRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "DescribeClusterGrafana")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeClusterGrafanaRequest::~DescribeClusterGrafanaRequest()
+{}
+
+std::string DescribeClusterGrafanaRequest::getK8sClusterId()const
+{
+	return k8sClusterId_;
+}
+
+void DescribeClusterGrafanaRequest::setK8sClusterId(const std::string& k8sClusterId)
+{
+	k8sClusterId_ = k8sClusterId;
+	setParameter("K8sClusterId", k8sClusterId);
+}
+
+std::string DescribeClusterGrafanaRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void DescribeClusterGrafanaRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setParameter("ServiceMeshId", serviceMeshId);
+}
+

servicemesh/src/model/DescribeClusterGrafanaResult.cc

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

servicemesh/src/model/DescribeClusterPrometheusRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/servicemesh/model/DescribeClusterPrometheusRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::DescribeClusterPrometheusRequest;
+
+DescribeClusterPrometheusRequest::DescribeClusterPrometheusRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "DescribeClusterPrometheus")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeClusterPrometheusRequest::~DescribeClusterPrometheusRequest()
+{}
+
+std::string DescribeClusterPrometheusRequest::getK8sClusterId()const
+{
+	return k8sClusterId_;
+}
+
+void DescribeClusterPrometheusRequest::setK8sClusterId(const std::string& k8sClusterId)
+{
+	k8sClusterId_ = k8sClusterId;
+	setParameter("K8sClusterId", k8sClusterId);
+}
+
+std::string DescribeClusterPrometheusRequest::getK8sClusterRegionId()const
+{
+	return k8sClusterRegionId_;
+}
+
+void DescribeClusterPrometheusRequest::setK8sClusterRegionId(const std::string& k8sClusterRegionId)
+{
+	k8sClusterRegionId_ = k8sClusterRegionId;
+	setParameter("K8sClusterRegionId", k8sClusterRegionId);
+}
+
+std::string DescribeClusterPrometheusRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void DescribeClusterPrometheusRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setParameter("ServiceMeshId", serviceMeshId);
+}
+

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

servicemesh/src/model/DescribeClustersInServiceMeshRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/DescribeClustersInServiceMeshRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::DescribeClustersInServiceMeshRequest;
+
+DescribeClustersInServiceMeshRequest::DescribeClustersInServiceMeshRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "DescribeClustersInServiceMesh")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeClustersInServiceMeshRequest::~DescribeClustersInServiceMeshRequest()
+{}
+
+std::string DescribeClustersInServiceMeshRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void DescribeClustersInServiceMeshRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setParameter("ServiceMeshId", serviceMeshId);
+}
+

servicemesh/src/model/DescribeClustersInServiceMeshResult.cc

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/DescribeClustersInServiceMeshResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Servicemesh;
+using namespace AlibabaCloud::Servicemesh::Model;
+
+DescribeClustersInServiceMeshResult::DescribeClustersInServiceMeshResult() :
+	ServiceResult()
+{}
+
+DescribeClustersInServiceMeshResult::DescribeClustersInServiceMeshResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeClustersInServiceMeshResult::~DescribeClustersInServiceMeshResult()
+{}
+
+void DescribeClustersInServiceMeshResult::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;
+		if(!valueClustersCluster["ClusterId"].isNull())
+			clustersObject.clusterId = valueClustersCluster["ClusterId"].asString();
+		if(!valueClustersCluster["ClusterType"].isNull())
+			clustersObject.clusterType = valueClustersCluster["ClusterType"].asString();
+		if(!valueClustersCluster["CreationTime"].isNull())
+			clustersObject.creationTime = valueClustersCluster["CreationTime"].asString();
+		if(!valueClustersCluster["ErrorMessage"].isNull())
+			clustersObject.errorMessage = valueClustersCluster["ErrorMessage"].asString();
+		if(!valueClustersCluster["Name"].isNull())
+			clustersObject.name = valueClustersCluster["Name"].asString();
+		if(!valueClustersCluster["RegionId"].isNull())
+			clustersObject.regionId = valueClustersCluster["RegionId"].asString();
+		if(!valueClustersCluster["State"].isNull())
+			clustersObject.state = valueClustersCluster["State"].asString();
+		if(!valueClustersCluster["UpdateTime"].isNull())
+			clustersObject.updateTime = valueClustersCluster["UpdateTime"].asString();
+		if(!valueClustersCluster["Version"].isNull())
+			clustersObject.version = valueClustersCluster["Version"].asString();
+		if(!valueClustersCluster["VpcId"].isNull())
+			clustersObject.vpcId = valueClustersCluster["VpcId"].asString();
+		if(!valueClustersCluster["SgId"].isNull())
+			clustersObject.sgId = valueClustersCluster["SgId"].asString();
+		if(!valueClustersCluster["ClusterDomain"].isNull())
+			clustersObject.clusterDomain = valueClustersCluster["ClusterDomain"].asString();
+		clusters_.push_back(clustersObject);
+	}
+
+}
+
+std::vector<DescribeClustersInServiceMeshResult::Cluster> DescribeClustersInServiceMeshResult::getClusters()const
+{
+	return clusters_;
+}
+

servicemesh/src/model/DescribeGuestClusterAccessLogDashboardsRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/DescribeGuestClusterAccessLogDashboardsRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::DescribeGuestClusterAccessLogDashboardsRequest;
+
+DescribeGuestClusterAccessLogDashboardsRequest::DescribeGuestClusterAccessLogDashboardsRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "DescribeGuestClusterAccessLogDashboards")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeGuestClusterAccessLogDashboardsRequest::~DescribeGuestClusterAccessLogDashboardsRequest()
+{}
+
+std::string DescribeGuestClusterAccessLogDashboardsRequest::getK8sClusterId()const
+{
+	return k8sClusterId_;
+}
+
+void DescribeGuestClusterAccessLogDashboardsRequest::setK8sClusterId(const std::string& k8sClusterId)
+{
+	k8sClusterId_ = k8sClusterId;
+	setBodyParameter("K8sClusterId", k8sClusterId);
+}
+

servicemesh/src/model/DescribeGuestClusterAccessLogDashboardsResult.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/servicemesh/model/DescribeGuestClusterAccessLogDashboardsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Servicemesh;
+using namespace AlibabaCloud::Servicemesh::Model;
+
+DescribeGuestClusterAccessLogDashboardsResult::DescribeGuestClusterAccessLogDashboardsResult() :
+	ServiceResult()
+{}
+
+DescribeGuestClusterAccessLogDashboardsResult::DescribeGuestClusterAccessLogDashboardsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeGuestClusterAccessLogDashboardsResult::~DescribeGuestClusterAccessLogDashboardsResult()
+{}
+
+void DescribeGuestClusterAccessLogDashboardsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDashboardsNode = value["Dashboards"]["DashboardsItem"];
+	for (auto valueDashboardsDashboardsItem : allDashboardsNode)
+	{
+		DashboardsItem dashboardsObject;
+		if(!valueDashboardsDashboardsItem["Title"].isNull())
+			dashboardsObject.title = valueDashboardsDashboardsItem["Title"].asString();
+		if(!valueDashboardsDashboardsItem["Url"].isNull())
+			dashboardsObject.url = valueDashboardsDashboardsItem["Url"].asString();
+		dashboards_.push_back(dashboardsObject);
+	}
+	if(!value["K8sClusterId"].isNull())
+		k8sClusterId_ = value["K8sClusterId"].asString();
+
+}
+
+std::vector<DescribeGuestClusterAccessLogDashboardsResult::DashboardsItem> DescribeGuestClusterAccessLogDashboardsResult::getDashboards()const
+{
+	return dashboards_;
+}
+
+std::string DescribeGuestClusterAccessLogDashboardsResult::getK8sClusterId()const
+{
+	return k8sClusterId_;
+}
+

servicemesh/src/model/DescribeIngressGatewaysRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/DescribeIngressGatewaysRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::DescribeIngressGatewaysRequest;
+
+DescribeIngressGatewaysRequest::DescribeIngressGatewaysRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "DescribeIngressGateways")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeIngressGatewaysRequest::~DescribeIngressGatewaysRequest()
+{}
+
+std::string DescribeIngressGatewaysRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void DescribeIngressGatewaysRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setParameter("ServiceMeshId", serviceMeshId);
+}
+

servicemesh/src/model/DescribeIngressGatewaysResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/servicemesh/model/DescribeIngressGatewaysResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Servicemesh;
+using namespace AlibabaCloud::Servicemesh::Model;
+
+DescribeIngressGatewaysResult::DescribeIngressGatewaysResult() :
+	ServiceResult()
+{}
+
+DescribeIngressGatewaysResult::DescribeIngressGatewaysResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeIngressGatewaysResult::~DescribeIngressGatewaysResult()
+{}
+
+void DescribeIngressGatewaysResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allIngressGateways = value["IngressGateways"]["IngressGateway"];
+	for (const auto &item : allIngressGateways)
+		ingressGateways_.push_back(item.asString());
+
+}
+
+std::vector<std::string> DescribeIngressGatewaysResult::getIngressGateways()const
+{
+	return ingressGateways_;
+}
+

servicemesh/src/model/DescribeServiceMeshDetailRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/DescribeServiceMeshDetailRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::DescribeServiceMeshDetailRequest;
+
+DescribeServiceMeshDetailRequest::DescribeServiceMeshDetailRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "DescribeServiceMeshDetail")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeServiceMeshDetailRequest::~DescribeServiceMeshDetailRequest()
+{}
+
+std::string DescribeServiceMeshDetailRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void DescribeServiceMeshDetailRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setBodyParameter("ServiceMeshId", serviceMeshId);
+}
+

servicemesh/src/model/DescribeServiceMeshDetailResult.cc

@@ -0,0 +1,164 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/DescribeServiceMeshDetailResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Servicemesh;
+using namespace AlibabaCloud::Servicemesh::Model;
+
+DescribeServiceMeshDetailResult::DescribeServiceMeshDetailResult() :
+	ServiceResult()
+{}
+
+DescribeServiceMeshDetailResult::DescribeServiceMeshDetailResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeServiceMeshDetailResult::~DescribeServiceMeshDetailResult()
+{}
+
+void DescribeServiceMeshDetailResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto serviceMeshNode = value["ServiceMesh"];
+	auto endpointsNode = serviceMeshNode["Endpoints"];
+	if(!endpointsNode["IntranetApiServerEndpoint"].isNull())
+		serviceMesh_.endpoints.intranetApiServerEndpoint = endpointsNode["IntranetApiServerEndpoint"].asString();
+	if(!endpointsNode["IntranetPilotEndpoint"].isNull())
+		serviceMesh_.endpoints.intranetPilotEndpoint = endpointsNode["IntranetPilotEndpoint"].asString();
+	if(!endpointsNode["PublicApiServerEndpoint"].isNull())
+		serviceMesh_.endpoints.publicApiServerEndpoint = endpointsNode["PublicApiServerEndpoint"].asString();
+	if(!endpointsNode["PublicPilotEndpoint"].isNull())
+		serviceMesh_.endpoints.publicPilotEndpoint = endpointsNode["PublicPilotEndpoint"].asString();
+	auto serviceMeshInfoNode = serviceMeshNode["ServiceMeshInfo"];
+	if(!serviceMeshInfoNode["CreationTime"].isNull())
+		serviceMesh_.serviceMeshInfo.creationTime = serviceMeshInfoNode["CreationTime"].asString();
+	if(!serviceMeshInfoNode["ErrorMessage"].isNull())
+		serviceMesh_.serviceMeshInfo.errorMessage = serviceMeshInfoNode["ErrorMessage"].asString();
+	if(!serviceMeshInfoNode["Name"].isNull())
+		serviceMesh_.serviceMeshInfo.name = serviceMeshInfoNode["Name"].asString();
+	if(!serviceMeshInfoNode["RegionId"].isNull())
+		serviceMesh_.serviceMeshInfo.regionId = serviceMeshInfoNode["RegionId"].asString();
+	if(!serviceMeshInfoNode["ServiceMeshId"].isNull())
+		serviceMesh_.serviceMeshInfo.serviceMeshId = serviceMeshInfoNode["ServiceMeshId"].asString();
+	if(!serviceMeshInfoNode["State"].isNull())
+		serviceMesh_.serviceMeshInfo.state = serviceMeshInfoNode["State"].asString();
+	if(!serviceMeshInfoNode["UpdateTime"].isNull())
+		serviceMesh_.serviceMeshInfo.updateTime = serviceMeshInfoNode["UpdateTime"].asString();
+	if(!serviceMeshInfoNode["Version"].isNull())
+		serviceMesh_.serviceMeshInfo.version = serviceMeshInfoNode["Version"].asString();
+	auto specNode = serviceMeshNode["Spec"];
+	auto loadBalancerNode = specNode["LoadBalancer"];
+	if(!loadBalancerNode["ApiServerLoadbalancerId"].isNull())
+		serviceMesh_.spec.loadBalancer.apiServerLoadbalancerId = loadBalancerNode["ApiServerLoadbalancerId"].asString();
+	if(!loadBalancerNode["ApiServerPublicEip"].isNull())
+		serviceMesh_.spec.loadBalancer.apiServerPublicEip = loadBalancerNode["ApiServerPublicEip"].asString() == "true";
+	if(!loadBalancerNode["PilotPublicEip"].isNull())
+		serviceMesh_.spec.loadBalancer.pilotPublicEip = loadBalancerNode["PilotPublicEip"].asString() == "true";
+	if(!loadBalancerNode["PilotPublicLoadbalancerId"].isNull())
+		serviceMesh_.spec.loadBalancer.pilotPublicLoadbalancerId = loadBalancerNode["PilotPublicLoadbalancerId"].asString();
+	auto meshConfigNode = specNode["MeshConfig"];
+	if(!meshConfigNode["EnableLocalityLB"].isNull())
+		serviceMesh_.spec.meshConfig.enableLocalityLB = meshConfigNode["EnableLocalityLB"].asString() == "true";
+	if(!meshConfigNode["Telemetry"].isNull())
+		serviceMesh_.spec.meshConfig.telemetry = meshConfigNode["Telemetry"].asString() == "true";
+	if(!meshConfigNode["Tracing"].isNull())
+		serviceMesh_.spec.meshConfig.tracing = meshConfigNode["Tracing"].asString() == "true";
+	if(!meshConfigNode["CustomizedZipkin"].isNull())
+		serviceMesh_.spec.meshConfig.customizedZipkin = meshConfigNode["CustomizedZipkin"].asString() == "true";
+	if(!meshConfigNode["OutboundTrafficPolicy"].isNull())
+		serviceMesh_.spec.meshConfig.outboundTrafficPolicy = meshConfigNode["OutboundTrafficPolicy"].asString();
+	if(!meshConfigNode["IncludeIPRanges"].isNull())
+		serviceMesh_.spec.meshConfig.includeIPRanges = meshConfigNode["IncludeIPRanges"].asString();
+	auto pilotNode = meshConfigNode["Pilot"];
+	if(!pilotNode["TraceSampling"].isNull())
+		serviceMesh_.spec.meshConfig.pilot.traceSampling = std::stof(pilotNode["TraceSampling"].asString());
+	if(!pilotNode["Http10Enabled"].isNull())
+		serviceMesh_.spec.meshConfig.pilot.http10Enabled = pilotNode["Http10Enabled"].asString() == "true";
+	auto oPANode = meshConfigNode["OPA"];
+	if(!oPANode["Enabled"].isNull())
+		serviceMesh_.spec.meshConfig.oPA.enabled = oPANode["Enabled"].asString() == "true";
+	if(!oPANode["LogLevel"].isNull())
+		serviceMesh_.spec.meshConfig.oPA.logLevel = oPANode["LogLevel"].asString();
+	if(!oPANode["RequestCPU"].isNull())
+		serviceMesh_.spec.meshConfig.oPA.requestCPU = oPANode["RequestCPU"].asString();
+	if(!oPANode["RequestMemory"].isNull())
+		serviceMesh_.spec.meshConfig.oPA.requestMemory = oPANode["RequestMemory"].asString();
+	if(!oPANode["LimitCPU"].isNull())
+		serviceMesh_.spec.meshConfig.oPA.limitCPU = oPANode["LimitCPU"].asString();
+	if(!oPANode["LimitMemory"].isNull())
+		serviceMesh_.spec.meshConfig.oPA.limitMemory = oPANode["LimitMemory"].asString();
+	auto auditNode = meshConfigNode["Audit"];
+	if(!auditNode["Enabled"].isNull())
+		serviceMesh_.spec.meshConfig.audit.enabled = auditNode["Enabled"].asString() == "true";
+	if(!auditNode["Project"].isNull())
+		serviceMesh_.spec.meshConfig.audit.project = auditNode["Project"].asString();
+	auto proxyNode = meshConfigNode["Proxy"];
+	if(!proxyNode["ClusterDomain"].isNull())
+		serviceMesh_.spec.meshConfig.proxy.clusterDomain = proxyNode["ClusterDomain"].asString();
+	if(!proxyNode["RequestCPU"].isNull())
+		serviceMesh_.spec.meshConfig.proxy.requestCPU = proxyNode["RequestCPU"].asString();
+	if(!proxyNode["RequestMemory"].isNull())
+		serviceMesh_.spec.meshConfig.proxy.requestMemory = proxyNode["RequestMemory"].asString();
+	if(!proxyNode["LimitCPU"].isNull())
+		serviceMesh_.spec.meshConfig.proxy.limitCPU = proxyNode["LimitCPU"].asString();
+	if(!proxyNode["LimitMemory"].isNull())
+		serviceMesh_.spec.meshConfig.proxy.limitMemory = proxyNode["LimitMemory"].asString();
+	auto sidecarInjectorNode = meshConfigNode["SidecarInjector"];
+	if(!sidecarInjectorNode["EnableNamespacesByDefault"].isNull())
+		serviceMesh_.spec.meshConfig.sidecarInjector.enableNamespacesByDefault = sidecarInjectorNode["EnableNamespacesByDefault"].asString() == "true";
+	if(!sidecarInjectorNode["AutoInjectionPolicyEnabled"].isNull())
+		serviceMesh_.spec.meshConfig.sidecarInjector.autoInjectionPolicyEnabled = sidecarInjectorNode["AutoInjectionPolicyEnabled"].asString() == "true";
+	if(!sidecarInjectorNode["RequestCPU"].isNull())
+		serviceMesh_.spec.meshConfig.sidecarInjector.requestCPU = sidecarInjectorNode["RequestCPU"].asString();
+	if(!sidecarInjectorNode["RequestMemory"].isNull())
+		serviceMesh_.spec.meshConfig.sidecarInjector.requestMemory = sidecarInjectorNode["RequestMemory"].asString();
+	if(!sidecarInjectorNode["LimitCPU"].isNull())
+		serviceMesh_.spec.meshConfig.sidecarInjector.limitCPU = sidecarInjectorNode["LimitCPU"].asString();
+	if(!sidecarInjectorNode["LimitMemory"].isNull())
+		serviceMesh_.spec.meshConfig.sidecarInjector.limitMemory = sidecarInjectorNode["LimitMemory"].asString();
+	if(!sidecarInjectorNode["SidecarInjectorWebhookAsYaml"].isNull())
+		serviceMesh_.spec.meshConfig.sidecarInjector.sidecarInjectorWebhookAsYaml = sidecarInjectorNode["SidecarInjectorWebhookAsYaml"].asString();
+	auto initCNIConfigurationNode = sidecarInjectorNode["InitCNIConfiguration"];
+	if(!initCNIConfigurationNode["Enabled"].isNull())
+		serviceMesh_.spec.meshConfig.sidecarInjector.initCNIConfiguration.enabled = initCNIConfigurationNode["Enabled"].asString() == "true";
+	if(!initCNIConfigurationNode["ExcludeNamespaces"].isNull())
+		serviceMesh_.spec.meshConfig.sidecarInjector.initCNIConfiguration.excludeNamespaces = initCNIConfigurationNode["ExcludeNamespaces"].asString();
+	auto networkNode = specNode["Network"];
+	if(!networkNode["SecurityGroupId"].isNull())
+		serviceMesh_.spec.network.securityGroupId = networkNode["SecurityGroupId"].asString();
+	if(!networkNode["VpcId"].isNull())
+		serviceMesh_.spec.network.vpcId = networkNode["VpcId"].asString();
+		auto allVSwitches = networkNode["VSwitches"]["VSwitch"];
+		for (auto value : allVSwitches)
+			serviceMesh_.spec.network.vSwitches.push_back(value.asString());
+		auto allClusters = serviceMeshNode["Clusters"]["Cluster"];
+		for (auto value : allClusters)
+			serviceMesh_.clusters.push_back(value.asString());
+
+}
+
+DescribeServiceMeshDetailResult::ServiceMesh DescribeServiceMeshDetailResult::getServiceMesh()const
+{
+	return serviceMesh_;
+}
+

servicemesh/src/model/DescribeServiceMeshKubeconfigRequest.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/servicemesh/model/DescribeServiceMeshKubeconfigRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::DescribeServiceMeshKubeconfigRequest;
+
+DescribeServiceMeshKubeconfigRequest::DescribeServiceMeshKubeconfigRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "DescribeServiceMeshKubeconfig")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeServiceMeshKubeconfigRequest::~DescribeServiceMeshKubeconfigRequest()
+{}
+
+bool DescribeServiceMeshKubeconfigRequest::getPrivateIpAddress()const
+{
+	return privateIpAddress_;
+}
+
+void DescribeServiceMeshKubeconfigRequest::setPrivateIpAddress(bool privateIpAddress)
+{
+	privateIpAddress_ = privateIpAddress;
+	setParameter("PrivateIpAddress", privateIpAddress ? "true" : "false");
+}
+
+std::string DescribeServiceMeshKubeconfigRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void DescribeServiceMeshKubeconfigRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setParameter("ServiceMeshId", serviceMeshId);
+}
+

servicemesh/src/model/DescribeServiceMeshKubeconfigResult.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/servicemesh/model/DescribeServiceMeshKubeconfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Servicemesh;
+using namespace AlibabaCloud::Servicemesh::Model;
+
+DescribeServiceMeshKubeconfigResult::DescribeServiceMeshKubeconfigResult() :
+	ServiceResult()
+{}
+
+DescribeServiceMeshKubeconfigResult::DescribeServiceMeshKubeconfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeServiceMeshKubeconfigResult::~DescribeServiceMeshKubeconfigResult()
+{}
+
+void DescribeServiceMeshKubeconfigResult::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 DescribeServiceMeshKubeconfigResult::getKubeconfig()const
+{
+	return kubeconfig_;
+}
+

servicemesh/src/model/DescribeServiceMeshesRequest.cc

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/DescribeServiceMeshesRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::DescribeServiceMeshesRequest;
+
+DescribeServiceMeshesRequest::DescribeServiceMeshesRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "DescribeServiceMeshes")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeServiceMeshesRequest::~DescribeServiceMeshesRequest()
+{}
+

servicemesh/src/model/DescribeServiceMeshesResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/servicemesh/model/DescribeServiceMeshesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Servicemesh;
+using namespace AlibabaCloud::Servicemesh::Model;
+
+DescribeServiceMeshesResult::DescribeServiceMeshesResult() :
+	ServiceResult()
+{}
+
+DescribeServiceMeshesResult::DescribeServiceMeshesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeServiceMeshesResult::~DescribeServiceMeshesResult()
+{}
+
+void DescribeServiceMeshesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allServiceMeshesNode = value["ServiceMeshes"]["ServiceMesh"];
+	for (auto valueServiceMeshesServiceMesh : allServiceMeshesNode)
+	{
+		ServiceMesh serviceMeshesObject;
+		auto endpointsNode = value["Endpoints"];
+		if(!endpointsNode["IntranetApiServerEndpoint"].isNull())
+			serviceMeshesObject.endpoints.intranetApiServerEndpoint = endpointsNode["IntranetApiServerEndpoint"].asString();
+		if(!endpointsNode["IntranetPilotEndpoint"].isNull())
+			serviceMeshesObject.endpoints.intranetPilotEndpoint = endpointsNode["IntranetPilotEndpoint"].asString();
+		if(!endpointsNode["PublicApiServerEndpoint"].isNull())
+			serviceMeshesObject.endpoints.publicApiServerEndpoint = endpointsNode["PublicApiServerEndpoint"].asString();
+		if(!endpointsNode["PublicPilotEndpoint"].isNull())
+			serviceMeshesObject.endpoints.publicPilotEndpoint = endpointsNode["PublicPilotEndpoint"].asString();
+		if(!endpointsNode["ReverseTunnelEndpoint"].isNull())
+			serviceMeshesObject.endpoints.reverseTunnelEndpoint = endpointsNode["ReverseTunnelEndpoint"].asString();
+		auto serviceMeshInfoNode = value["ServiceMeshInfo"];
+		if(!serviceMeshInfoNode["CreationTime"].isNull())
+			serviceMeshesObject.serviceMeshInfo.creationTime = serviceMeshInfoNode["CreationTime"].asString();
+		if(!serviceMeshInfoNode["ErrorMessage"].isNull())
+			serviceMeshesObject.serviceMeshInfo.errorMessage = serviceMeshInfoNode["ErrorMessage"].asString();
+		if(!serviceMeshInfoNode["Name"].isNull())
+			serviceMeshesObject.serviceMeshInfo.name = serviceMeshInfoNode["Name"].asString();
+		if(!serviceMeshInfoNode["RegionId"].isNull())
+			serviceMeshesObject.serviceMeshInfo.regionId = serviceMeshInfoNode["RegionId"].asString();
+		if(!serviceMeshInfoNode["ServiceMeshId"].isNull())
+			serviceMeshesObject.serviceMeshInfo.serviceMeshId = serviceMeshInfoNode["ServiceMeshId"].asString();
+		if(!serviceMeshInfoNode["State"].isNull())
+			serviceMeshesObject.serviceMeshInfo.state = serviceMeshInfoNode["State"].asString();
+		if(!serviceMeshInfoNode["UpdateTime"].isNull())
+			serviceMeshesObject.serviceMeshInfo.updateTime = serviceMeshInfoNode["UpdateTime"].asString();
+		if(!serviceMeshInfoNode["Version"].isNull())
+			serviceMeshesObject.serviceMeshInfo.version = serviceMeshInfoNode["Version"].asString();
+		auto specNode = value["Spec"];
+		auto loadBalancerNode = specNode["LoadBalancer"];
+		if(!loadBalancerNode["ApiServerLoadbalancerId"].isNull())
+			serviceMeshesObject.spec.loadBalancer.apiServerLoadbalancerId = loadBalancerNode["ApiServerLoadbalancerId"].asString();
+		if(!loadBalancerNode["ApiServerPublicEip"].isNull())
+			serviceMeshesObject.spec.loadBalancer.apiServerPublicEip = loadBalancerNode["ApiServerPublicEip"].asString() == "true";
+		if(!loadBalancerNode["PilotPublicEip"].isNull())
+			serviceMeshesObject.spec.loadBalancer.pilotPublicEip = loadBalancerNode["PilotPublicEip"].asString() == "true";
+		if(!loadBalancerNode["PilotPublicLoadbalancerId"].isNull())
+			serviceMeshesObject.spec.loadBalancer.pilotPublicLoadbalancerId = loadBalancerNode["PilotPublicLoadbalancerId"].asString();
+		auto meshConfigNode = specNode["MeshConfig"];
+		if(!meshConfigNode["Mtls"].isNull())
+			serviceMeshesObject.spec.meshConfig.mtls = meshConfigNode["Mtls"].asString() == "true";
+		if(!meshConfigNode["OutboundTrafficPolicy"].isNull())
+			serviceMeshesObject.spec.meshConfig.outboundTrafficPolicy = meshConfigNode["OutboundTrafficPolicy"].asString();
+		if(!meshConfigNode["StrictMtls"].isNull())
+			serviceMeshesObject.spec.meshConfig.strictMtls = meshConfigNode["StrictMtls"].asString() == "true";
+		if(!meshConfigNode["Tracing"].isNull())
+			serviceMeshesObject.spec.meshConfig.tracing = meshConfigNode["Tracing"].asString() == "true";
+		if(!meshConfigNode["Telemetry"].isNull())
+			serviceMeshesObject.spec.meshConfig.telemetry = meshConfigNode["Telemetry"].asString() == "true";
+		auto pilotNode = meshConfigNode["Pilot"];
+		if(!pilotNode["TraceSampling"].isNull())
+			serviceMeshesObject.spec.meshConfig.pilot.traceSampling = std::stof(pilotNode["TraceSampling"].asString());
+		if(!pilotNode["Http10Enabled"].isNull())
+			serviceMeshesObject.spec.meshConfig.pilot.http10Enabled = pilotNode["Http10Enabled"].asString() == "true";
+		auto sidecarInjectorNode = meshConfigNode["SidecarInjector"];
+		if(!sidecarInjectorNode["EnableNamespacesByDefault"].isNull())
+			serviceMeshesObject.spec.meshConfig.sidecarInjector.enableNamespacesByDefault = sidecarInjectorNode["EnableNamespacesByDefault"].asString() == "true";
+		if(!sidecarInjectorNode["AutoInjectionPolicyEnabled"].isNull())
+			serviceMeshesObject.spec.meshConfig.sidecarInjector.autoInjectionPolicyEnabled = sidecarInjectorNode["AutoInjectionPolicyEnabled"].asString() == "true";
+		auto initCNIConfigurationNode = sidecarInjectorNode["InitCNIConfiguration"];
+		if(!initCNIConfigurationNode["Enabled"].isNull())
+			serviceMeshesObject.spec.meshConfig.sidecarInjector.initCNIConfiguration.enabled = initCNIConfigurationNode["Enabled"].asString() == "true";
+		if(!initCNIConfigurationNode["ExcludeNamespaces"].isNull())
+			serviceMeshesObject.spec.meshConfig.sidecarInjector.initCNIConfiguration.excludeNamespaces = initCNIConfigurationNode["ExcludeNamespaces"].asString();
+		auto networkNode = specNode["Network"];
+		if(!networkNode["SecurityGroupId"].isNull())
+			serviceMeshesObject.spec.network.securityGroupId = networkNode["SecurityGroupId"].asString();
+		if(!networkNode["VpcId"].isNull())
+			serviceMeshesObject.spec.network.vpcId = networkNode["VpcId"].asString();
+			auto allVSwitches = networkNode["VSwitches"]["VSwitch"];
+			for (auto value : allVSwitches)
+				serviceMeshesObject.spec.network.vSwitches.push_back(value.asString());
+		auto allClusters = value["Clusters"]["Cluster"];
+		for (auto value : allClusters)
+			serviceMeshesObject.clusters.push_back(value.asString());
+		serviceMeshes_.push_back(serviceMeshesObject);
+	}
+
+}
+
+std::vector<DescribeServiceMeshesResult::ServiceMesh> DescribeServiceMeshesResult::getServiceMeshes()const
+{
+	return serviceMeshes_;
+}
+

servicemesh/src/model/DescribeUpgradeVersionRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/DescribeUpgradeVersionRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::DescribeUpgradeVersionRequest;
+
+DescribeUpgradeVersionRequest::DescribeUpgradeVersionRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "DescribeUpgradeVersion")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeUpgradeVersionRequest::~DescribeUpgradeVersionRequest()
+{}
+
+std::string DescribeUpgradeVersionRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void DescribeUpgradeVersionRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setParameter("ServiceMeshId", serviceMeshId);
+}
+

servicemesh/src/model/DescribeUpgradeVersionResult.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/servicemesh/model/DescribeUpgradeVersionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Servicemesh;
+using namespace AlibabaCloud::Servicemesh::Model;
+
+DescribeUpgradeVersionResult::DescribeUpgradeVersionResult() :
+	ServiceResult()
+{}
+
+DescribeUpgradeVersionResult::DescribeUpgradeVersionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeUpgradeVersionResult::~DescribeUpgradeVersionResult()
+{}
+
+void DescribeUpgradeVersionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto versionNode = value["Version"];
+	if(!versionNode["IstioVersion"].isNull())
+		version_.istioVersion = versionNode["IstioVersion"].asString();
+	if(!versionNode["IstioOperatorVersion"].isNull())
+		version_.istioOperatorVersion = versionNode["IstioOperatorVersion"].asString();
+	if(!versionNode["KubernetesVersion"].isNull())
+		version_.kubernetesVersion = versionNode["KubernetesVersion"].asString();
+
+}
+
+DescribeUpgradeVersionResult::Version DescribeUpgradeVersionResult::getVersion()const
+{
+	return version_;
+}
+

servicemesh/src/model/GetDiagnosisRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/GetDiagnosisRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::GetDiagnosisRequest;
+
+GetDiagnosisRequest::GetDiagnosisRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "GetDiagnosis")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetDiagnosisRequest::~GetDiagnosisRequest()
+{}
+
+std::string GetDiagnosisRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void GetDiagnosisRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setParameter("ServiceMeshId", serviceMeshId);
+}
+

servicemesh/src/model/GetDiagnosisResult.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/servicemesh/model/GetDiagnosisResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Servicemesh;
+using namespace AlibabaCloud::Servicemesh::Model;
+
+GetDiagnosisResult::GetDiagnosisResult() :
+	ServiceResult()
+{}
+
+GetDiagnosisResult::GetDiagnosisResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetDiagnosisResult::~GetDiagnosisResult()
+{}
+
+void GetDiagnosisResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Result"].isNull())
+		result_ = value["Result"].asString();
+	if(!value["RunAt"].isNull())
+		runAt_ = value["RunAt"].asString();
+
+}
+
+std::string GetDiagnosisResult::getRunAt()const
+{
+	return runAt_;
+}
+
+std::string GetDiagnosisResult::getResult()const
+{
+	return result_;
+}
+

servicemesh/src/model/GetRegisteredServiceEndpointsRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/servicemesh/model/GetRegisteredServiceEndpointsRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::GetRegisteredServiceEndpointsRequest;
+
+GetRegisteredServiceEndpointsRequest::GetRegisteredServiceEndpointsRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "GetRegisteredServiceEndpoints")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetRegisteredServiceEndpointsRequest::~GetRegisteredServiceEndpointsRequest()
+{}
+
+std::string GetRegisteredServiceEndpointsRequest::get_Namespace()const
+{
+	return _namespace_;
+}
+
+void GetRegisteredServiceEndpointsRequest::set_Namespace(const std::string& _namespace)
+{
+	_namespace_ = _namespace;
+	setParameter("_Namespace", _namespace);
+}
+
+std::string GetRegisteredServiceEndpointsRequest::getName()const
+{
+	return name_;
+}
+
+void GetRegisteredServiceEndpointsRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string GetRegisteredServiceEndpointsRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void GetRegisteredServiceEndpointsRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setParameter("ServiceMeshId", serviceMeshId);
+}
+

servicemesh/src/model/GetRegisteredServiceEndpointsResult.cc

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

servicemesh/src/model/GetRegisteredServiceNamespacesRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/GetRegisteredServiceNamespacesRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::GetRegisteredServiceNamespacesRequest;
+
+GetRegisteredServiceNamespacesRequest::GetRegisteredServiceNamespacesRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "GetRegisteredServiceNamespaces")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetRegisteredServiceNamespacesRequest::~GetRegisteredServiceNamespacesRequest()
+{}
+
+std::string GetRegisteredServiceNamespacesRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void GetRegisteredServiceNamespacesRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setBodyParameter("ServiceMeshId", serviceMeshId);
+}
+

servicemesh/src/model/GetRegisteredServiceNamespacesResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/servicemesh/model/GetRegisteredServiceNamespacesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Servicemesh;
+using namespace AlibabaCloud::Servicemesh::Model;
+
+GetRegisteredServiceNamespacesResult::GetRegisteredServiceNamespacesResult() :
+	ServiceResult()
+{}
+
+GetRegisteredServiceNamespacesResult::GetRegisteredServiceNamespacesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetRegisteredServiceNamespacesResult::~GetRegisteredServiceNamespacesResult()
+{}
+
+void GetRegisteredServiceNamespacesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allNamespaces = value["Namespaces"]["Namespace"];
+	for (const auto &item : allNamespaces)
+		namespaces_.push_back(item.asString());
+
+}
+
+std::vector<std::string> GetRegisteredServiceNamespacesResult::getNamespaces()const
+{
+	return namespaces_;
+}
+

servicemesh/src/model/GetRegisteredServicesRequest.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/servicemesh/model/GetRegisteredServicesRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::GetRegisteredServicesRequest;
+
+GetRegisteredServicesRequest::GetRegisteredServicesRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "GetRegisteredServices")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetRegisteredServicesRequest::~GetRegisteredServicesRequest()
+{}
+
+std::string GetRegisteredServicesRequest::get_Namespace()const
+{
+	return _namespace_;
+}
+
+void GetRegisteredServicesRequest::set_Namespace(const std::string& _namespace)
+{
+	_namespace_ = _namespace;
+	setParameter("_Namespace", _namespace);
+}
+
+std::string GetRegisteredServicesRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void GetRegisteredServicesRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setParameter("ServiceMeshId", serviceMeshId);
+}
+

servicemesh/src/model/GetRegisteredServicesResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/servicemesh/model/GetRegisteredServicesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Servicemesh;
+using namespace AlibabaCloud::Servicemesh::Model;
+
+GetRegisteredServicesResult::GetRegisteredServicesResult() :
+	ServiceResult()
+{}
+
+GetRegisteredServicesResult::GetRegisteredServicesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetRegisteredServicesResult::~GetRegisteredServicesResult()
+{}
+
+void GetRegisteredServicesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allServices = value["Services"]["Service"];
+	for (const auto &item : allServices)
+		services_.push_back(item.asString());
+
+}
+
+std::vector<std::string> GetRegisteredServicesResult::getServices()const
+{
+	return services_;
+}
+

servicemesh/src/model/GetServiceMeshSlbRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/GetServiceMeshSlbRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::GetServiceMeshSlbRequest;
+
+GetServiceMeshSlbRequest::GetServiceMeshSlbRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "GetServiceMeshSlb")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetServiceMeshSlbRequest::~GetServiceMeshSlbRequest()
+{}
+
+std::string GetServiceMeshSlbRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void GetServiceMeshSlbRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setParameter("ServiceMeshId", serviceMeshId);
+}
+

servicemesh/src/model/GetServiceMeshSlbResult.cc

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/GetServiceMeshSlbResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Servicemesh;
+using namespace AlibabaCloud::Servicemesh::Model;
+
+GetServiceMeshSlbResult::GetServiceMeshSlbResult() :
+	ServiceResult()
+{}
+
+GetServiceMeshSlbResult::GetServiceMeshSlbResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetServiceMeshSlbResult::~GetServiceMeshSlbResult()
+{}
+
+void GetServiceMeshSlbResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["SLBInfo"];
+	for (auto valueDataSLBInfo : allDataNode)
+	{
+		SLBInfo dataObject;
+		if(!valueDataSLBInfo["LoadBalancerId"].isNull())
+			dataObject.loadBalancerId = valueDataSLBInfo["LoadBalancerId"].asString();
+		if(!valueDataSLBInfo["Status"].isNull())
+			dataObject.status = valueDataSLBInfo["Status"].asString();
+		if(!valueDataSLBInfo["ServerHealthStatus"].isNull())
+			dataObject.serverHealthStatus = valueDataSLBInfo["ServerHealthStatus"].asString();
+		data_.push_back(dataObject);
+	}
+
+}
+
+std::vector<GetServiceMeshSlbResult::SLBInfo> GetServiceMeshSlbResult::getData()const
+{
+	return data_;
+}
+

servicemesh/src/model/GetVmAppMeshInfoRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/servicemesh/model/GetVmAppMeshInfoRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::GetVmAppMeshInfoRequest;
+
+GetVmAppMeshInfoRequest::GetVmAppMeshInfoRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "GetVmAppMeshInfo")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+GetVmAppMeshInfoRequest::~GetVmAppMeshInfoRequest()
+{}
+
+std::string GetVmAppMeshInfoRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void GetVmAppMeshInfoRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setParameter("ServiceMeshId", serviceMeshId);
+}
+

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

servicemesh/src/model/GetVmMetaRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/servicemesh/model/GetVmMetaRequest.h>
+
+using AlibabaCloud::Servicemesh::Model::GetVmMetaRequest;
+
+GetVmMetaRequest::GetVmMetaRequest() :
+	RpcServiceRequest("servicemesh", "2020-01-11", "GetVmMeta")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+GetVmMetaRequest::~GetVmMetaRequest()
+{}
+
+std::string GetVmMetaRequest::getServiceAccount()const
+{
+	return serviceAccount_;
+}
+
+void GetVmMetaRequest::setServiceAccount(const std::string& serviceAccount)
+{
+	serviceAccount_ = serviceAccount;
+	setParameter("ServiceAccount", serviceAccount);
+}
+
+std::string GetVmMetaRequest::getTrustDomain()const
+{
+	return trustDomain_;
+}
+
+void GetVmMetaRequest::setTrustDomain(const std::string& trustDomain)
+{
+	trustDomain_ = trustDomain;
+	setParameter("TrustDomain", trustDomain);
+}
+
+std::string GetVmMetaRequest::get_Namespace()const
+{
+	return _namespace_;
+}
+
+void GetVmMetaRequest::set_Namespace(const std::string& _namespace)
+{
+	_namespace_ = _namespace;
+	setParameter("_Namespace", _namespace);
+}
+
+std::string GetVmMetaRequest::getServiceMeshId()const
+{
+	return serviceMeshId_;
+}
+
+void GetVmMetaRequest::setServiceMeshId(const std::string& serviceMeshId)
+{
+	serviceMeshId_ = serviceMeshId;
+	setParameter("ServiceMeshId", serviceMeshId);
+}
+