Modify some field types.

CHANGELOG

@@ -1,3 +1,6 @@
+2021-01-21 Version: patch
+- Modify some field types.
+
 2021-01-21 Version: patch
 - Generated 2019-09-10 for `waf-openapi`.
 

privatelink/CMakeLists.txt

@@ -0,0 +1,202 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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(privatelink_public_header 
+	include/alibabacloud/privatelink/PrivatelinkClient.h
+	include/alibabacloud/privatelink/PrivatelinkExport.h )
+
+set(privatelink_public_header_model 
+	include/alibabacloud/privatelink/model/AddUserToVpcEndpointServiceRequest.h
+	include/alibabacloud/privatelink/model/AddUserToVpcEndpointServiceResult.h
+	include/alibabacloud/privatelink/model/AddZoneToVpcEndpointRequest.h
+	include/alibabacloud/privatelink/model/AddZoneToVpcEndpointResult.h
+	include/alibabacloud/privatelink/model/AttachResourceToVpcEndpointServiceRequest.h
+	include/alibabacloud/privatelink/model/AttachResourceToVpcEndpointServiceResult.h
+	include/alibabacloud/privatelink/model/AttachSecurityGroupToVpcEndpointRequest.h
+	include/alibabacloud/privatelink/model/AttachSecurityGroupToVpcEndpointResult.h
+	include/alibabacloud/privatelink/model/CreateVpcEndpointRequest.h
+	include/alibabacloud/privatelink/model/CreateVpcEndpointResult.h
+	include/alibabacloud/privatelink/model/CreateVpcEndpointServiceRequest.h
+	include/alibabacloud/privatelink/model/CreateVpcEndpointServiceResult.h
+	include/alibabacloud/privatelink/model/DeleteVpcEndpointRequest.h
+	include/alibabacloud/privatelink/model/DeleteVpcEndpointResult.h
+	include/alibabacloud/privatelink/model/DeleteVpcEndpointServiceRequest.h
+	include/alibabacloud/privatelink/model/DeleteVpcEndpointServiceResult.h
+	include/alibabacloud/privatelink/model/DescribeRegionsRequest.h
+	include/alibabacloud/privatelink/model/DescribeRegionsResult.h
+	include/alibabacloud/privatelink/model/DescribeZonesRequest.h
+	include/alibabacloud/privatelink/model/DescribeZonesResult.h
+	include/alibabacloud/privatelink/model/DetachResourceFromVpcEndpointServiceRequest.h
+	include/alibabacloud/privatelink/model/DetachResourceFromVpcEndpointServiceResult.h
+	include/alibabacloud/privatelink/model/DetachSecurityGroupFromVpcEndpointRequest.h
+	include/alibabacloud/privatelink/model/DetachSecurityGroupFromVpcEndpointResult.h
+	include/alibabacloud/privatelink/model/DisableVpcEndpointConnectionRequest.h
+	include/alibabacloud/privatelink/model/DisableVpcEndpointConnectionResult.h
+	include/alibabacloud/privatelink/model/EnableVpcEndpointConnectionRequest.h
+	include/alibabacloud/privatelink/model/EnableVpcEndpointConnectionResult.h
+	include/alibabacloud/privatelink/model/GetVpcEndpointAttributeRequest.h
+	include/alibabacloud/privatelink/model/GetVpcEndpointAttributeResult.h
+	include/alibabacloud/privatelink/model/GetVpcEndpointServiceAttributeRequest.h
+	include/alibabacloud/privatelink/model/GetVpcEndpointServiceAttributeResult.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointConnectionsRequest.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointConnectionsResult.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointSecurityGroupsRequest.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointSecurityGroupsResult.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointServiceResourcesRequest.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointServiceResourcesResult.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointServiceUsersRequest.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointServiceUsersResult.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointServicesRequest.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointServicesResult.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointServicesByEndUserRequest.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointServicesByEndUserResult.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointZonesRequest.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointZonesResult.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointsRequest.h
+	include/alibabacloud/privatelink/model/ListVpcEndpointsResult.h
+	include/alibabacloud/privatelink/model/OpenPrivateLinkServiceRequest.h
+	include/alibabacloud/privatelink/model/OpenPrivateLinkServiceResult.h
+	include/alibabacloud/privatelink/model/RemoveUserFromVpcEndpointServiceRequest.h
+	include/alibabacloud/privatelink/model/RemoveUserFromVpcEndpointServiceResult.h
+	include/alibabacloud/privatelink/model/RemoveZoneFromVpcEndpointRequest.h
+	include/alibabacloud/privatelink/model/RemoveZoneFromVpcEndpointResult.h
+	include/alibabacloud/privatelink/model/UpdateVpcEndpointAttributeRequest.h
+	include/alibabacloud/privatelink/model/UpdateVpcEndpointAttributeResult.h
+	include/alibabacloud/privatelink/model/UpdateVpcEndpointConnectionAttributeRequest.h
+	include/alibabacloud/privatelink/model/UpdateVpcEndpointConnectionAttributeResult.h
+	include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceAttributeRequest.h
+	include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceAttributeResult.h )
+
+set(privatelink_src 
+	src/PrivatelinkClient.cc
+	src/model/AddUserToVpcEndpointServiceRequest.cc
+	src/model/AddUserToVpcEndpointServiceResult.cc
+	src/model/AddZoneToVpcEndpointRequest.cc
+	src/model/AddZoneToVpcEndpointResult.cc
+	src/model/AttachResourceToVpcEndpointServiceRequest.cc
+	src/model/AttachResourceToVpcEndpointServiceResult.cc
+	src/model/AttachSecurityGroupToVpcEndpointRequest.cc
+	src/model/AttachSecurityGroupToVpcEndpointResult.cc
+	src/model/CreateVpcEndpointRequest.cc
+	src/model/CreateVpcEndpointResult.cc
+	src/model/CreateVpcEndpointServiceRequest.cc
+	src/model/CreateVpcEndpointServiceResult.cc
+	src/model/DeleteVpcEndpointRequest.cc
+	src/model/DeleteVpcEndpointResult.cc
+	src/model/DeleteVpcEndpointServiceRequest.cc
+	src/model/DeleteVpcEndpointServiceResult.cc
+	src/model/DescribeRegionsRequest.cc
+	src/model/DescribeRegionsResult.cc
+	src/model/DescribeZonesRequest.cc
+	src/model/DescribeZonesResult.cc
+	src/model/DetachResourceFromVpcEndpointServiceRequest.cc
+	src/model/DetachResourceFromVpcEndpointServiceResult.cc
+	src/model/DetachSecurityGroupFromVpcEndpointRequest.cc
+	src/model/DetachSecurityGroupFromVpcEndpointResult.cc
+	src/model/DisableVpcEndpointConnectionRequest.cc
+	src/model/DisableVpcEndpointConnectionResult.cc
+	src/model/EnableVpcEndpointConnectionRequest.cc
+	src/model/EnableVpcEndpointConnectionResult.cc
+	src/model/GetVpcEndpointAttributeRequest.cc
+	src/model/GetVpcEndpointAttributeResult.cc
+	src/model/GetVpcEndpointServiceAttributeRequest.cc
+	src/model/GetVpcEndpointServiceAttributeResult.cc
+	src/model/ListVpcEndpointConnectionsRequest.cc
+	src/model/ListVpcEndpointConnectionsResult.cc
+	src/model/ListVpcEndpointSecurityGroupsRequest.cc
+	src/model/ListVpcEndpointSecurityGroupsResult.cc
+	src/model/ListVpcEndpointServiceResourcesRequest.cc
+	src/model/ListVpcEndpointServiceResourcesResult.cc
+	src/model/ListVpcEndpointServiceUsersRequest.cc
+	src/model/ListVpcEndpointServiceUsersResult.cc
+	src/model/ListVpcEndpointServicesRequest.cc
+	src/model/ListVpcEndpointServicesResult.cc
+	src/model/ListVpcEndpointServicesByEndUserRequest.cc
+	src/model/ListVpcEndpointServicesByEndUserResult.cc
+	src/model/ListVpcEndpointZonesRequest.cc
+	src/model/ListVpcEndpointZonesResult.cc
+	src/model/ListVpcEndpointsRequest.cc
+	src/model/ListVpcEndpointsResult.cc
+	src/model/OpenPrivateLinkServiceRequest.cc
+	src/model/OpenPrivateLinkServiceResult.cc
+	src/model/RemoveUserFromVpcEndpointServiceRequest.cc
+	src/model/RemoveUserFromVpcEndpointServiceResult.cc
+	src/model/RemoveZoneFromVpcEndpointRequest.cc
+	src/model/RemoveZoneFromVpcEndpointResult.cc
+	src/model/UpdateVpcEndpointAttributeRequest.cc
+	src/model/UpdateVpcEndpointAttributeResult.cc
+	src/model/UpdateVpcEndpointConnectionAttributeRequest.cc
+	src/model/UpdateVpcEndpointConnectionAttributeResult.cc
+	src/model/UpdateVpcEndpointServiceAttributeRequest.cc
+	src/model/UpdateVpcEndpointServiceAttributeResult.cc )
+
+add_library(privatelink ${LIB_TYPE}
+	${privatelink_public_header}
+	${privatelink_public_header_model}
+	${privatelink_src})
+
+set_target_properties(privatelink
+	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}privatelink
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(privatelink
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_PRIVATELINK_LIBRARY)
+endif()
+
+target_include_directories(privatelink
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(privatelink
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(privatelink
+		jsoncpp)
+	target_include_directories(privatelink
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(privatelink
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(privatelink
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(privatelink
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(privatelink
+		jsoncpp)
+endif()
+
+install(FILES ${privatelink_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/privatelink)
+install(FILES ${privatelink_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/privatelink/model)
+install(TARGETS privatelink
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

privatelink/include/alibabacloud/privatelink/PrivatelinkClient.h

@@ -0,0 +1,286 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_PRIVATELINK_PRIVATELINKCLIENT_H_
+#define ALIBABACLOUD_PRIVATELINK_PRIVATELINKCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "PrivatelinkExport.h"
+#include "model/AddUserToVpcEndpointServiceRequest.h"
+#include "model/AddUserToVpcEndpointServiceResult.h"
+#include "model/AddZoneToVpcEndpointRequest.h"
+#include "model/AddZoneToVpcEndpointResult.h"
+#include "model/AttachResourceToVpcEndpointServiceRequest.h"
+#include "model/AttachResourceToVpcEndpointServiceResult.h"
+#include "model/AttachSecurityGroupToVpcEndpointRequest.h"
+#include "model/AttachSecurityGroupToVpcEndpointResult.h"
+#include "model/CreateVpcEndpointRequest.h"
+#include "model/CreateVpcEndpointResult.h"
+#include "model/CreateVpcEndpointServiceRequest.h"
+#include "model/CreateVpcEndpointServiceResult.h"
+#include "model/DeleteVpcEndpointRequest.h"
+#include "model/DeleteVpcEndpointResult.h"
+#include "model/DeleteVpcEndpointServiceRequest.h"
+#include "model/DeleteVpcEndpointServiceResult.h"
+#include "model/DescribeRegionsRequest.h"
+#include "model/DescribeRegionsResult.h"
+#include "model/DescribeZonesRequest.h"
+#include "model/DescribeZonesResult.h"
+#include "model/DetachResourceFromVpcEndpointServiceRequest.h"
+#include "model/DetachResourceFromVpcEndpointServiceResult.h"
+#include "model/DetachSecurityGroupFromVpcEndpointRequest.h"
+#include "model/DetachSecurityGroupFromVpcEndpointResult.h"
+#include "model/DisableVpcEndpointConnectionRequest.h"
+#include "model/DisableVpcEndpointConnectionResult.h"
+#include "model/EnableVpcEndpointConnectionRequest.h"
+#include "model/EnableVpcEndpointConnectionResult.h"
+#include "model/GetVpcEndpointAttributeRequest.h"
+#include "model/GetVpcEndpointAttributeResult.h"
+#include "model/GetVpcEndpointServiceAttributeRequest.h"
+#include "model/GetVpcEndpointServiceAttributeResult.h"
+#include "model/ListVpcEndpointConnectionsRequest.h"
+#include "model/ListVpcEndpointConnectionsResult.h"
+#include "model/ListVpcEndpointSecurityGroupsRequest.h"
+#include "model/ListVpcEndpointSecurityGroupsResult.h"
+#include "model/ListVpcEndpointServiceResourcesRequest.h"
+#include "model/ListVpcEndpointServiceResourcesResult.h"
+#include "model/ListVpcEndpointServiceUsersRequest.h"
+#include "model/ListVpcEndpointServiceUsersResult.h"
+#include "model/ListVpcEndpointServicesRequest.h"
+#include "model/ListVpcEndpointServicesResult.h"
+#include "model/ListVpcEndpointServicesByEndUserRequest.h"
+#include "model/ListVpcEndpointServicesByEndUserResult.h"
+#include "model/ListVpcEndpointZonesRequest.h"
+#include "model/ListVpcEndpointZonesResult.h"
+#include "model/ListVpcEndpointsRequest.h"
+#include "model/ListVpcEndpointsResult.h"
+#include "model/OpenPrivateLinkServiceRequest.h"
+#include "model/OpenPrivateLinkServiceResult.h"
+#include "model/RemoveUserFromVpcEndpointServiceRequest.h"
+#include "model/RemoveUserFromVpcEndpointServiceResult.h"
+#include "model/RemoveZoneFromVpcEndpointRequest.h"
+#include "model/RemoveZoneFromVpcEndpointResult.h"
+#include "model/UpdateVpcEndpointAttributeRequest.h"
+#include "model/UpdateVpcEndpointAttributeResult.h"
+#include "model/UpdateVpcEndpointConnectionAttributeRequest.h"
+#include "model/UpdateVpcEndpointConnectionAttributeResult.h"
+#include "model/UpdateVpcEndpointServiceAttributeRequest.h"
+#include "model/UpdateVpcEndpointServiceAttributeResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		class ALIBABACLOUD_PRIVATELINK_EXPORT PrivatelinkClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::AddUserToVpcEndpointServiceResult> AddUserToVpcEndpointServiceOutcome;
+			typedef std::future<AddUserToVpcEndpointServiceOutcome> AddUserToVpcEndpointServiceOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::AddUserToVpcEndpointServiceRequest&, const AddUserToVpcEndpointServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddUserToVpcEndpointServiceAsyncHandler;
+			typedef Outcome<Error, Model::AddZoneToVpcEndpointResult> AddZoneToVpcEndpointOutcome;
+			typedef std::future<AddZoneToVpcEndpointOutcome> AddZoneToVpcEndpointOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::AddZoneToVpcEndpointRequest&, const AddZoneToVpcEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddZoneToVpcEndpointAsyncHandler;
+			typedef Outcome<Error, Model::AttachResourceToVpcEndpointServiceResult> AttachResourceToVpcEndpointServiceOutcome;
+			typedef std::future<AttachResourceToVpcEndpointServiceOutcome> AttachResourceToVpcEndpointServiceOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::AttachResourceToVpcEndpointServiceRequest&, const AttachResourceToVpcEndpointServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachResourceToVpcEndpointServiceAsyncHandler;
+			typedef Outcome<Error, Model::AttachSecurityGroupToVpcEndpointResult> AttachSecurityGroupToVpcEndpointOutcome;
+			typedef std::future<AttachSecurityGroupToVpcEndpointOutcome> AttachSecurityGroupToVpcEndpointOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::AttachSecurityGroupToVpcEndpointRequest&, const AttachSecurityGroupToVpcEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachSecurityGroupToVpcEndpointAsyncHandler;
+			typedef Outcome<Error, Model::CreateVpcEndpointResult> CreateVpcEndpointOutcome;
+			typedef std::future<CreateVpcEndpointOutcome> CreateVpcEndpointOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::CreateVpcEndpointRequest&, const CreateVpcEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVpcEndpointAsyncHandler;
+			typedef Outcome<Error, Model::CreateVpcEndpointServiceResult> CreateVpcEndpointServiceOutcome;
+			typedef std::future<CreateVpcEndpointServiceOutcome> CreateVpcEndpointServiceOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::CreateVpcEndpointServiceRequest&, const CreateVpcEndpointServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVpcEndpointServiceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteVpcEndpointResult> DeleteVpcEndpointOutcome;
+			typedef std::future<DeleteVpcEndpointOutcome> DeleteVpcEndpointOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::DeleteVpcEndpointRequest&, const DeleteVpcEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVpcEndpointAsyncHandler;
+			typedef Outcome<Error, Model::DeleteVpcEndpointServiceResult> DeleteVpcEndpointServiceOutcome;
+			typedef std::future<DeleteVpcEndpointServiceOutcome> DeleteVpcEndpointServiceOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::DeleteVpcEndpointServiceRequest&, const DeleteVpcEndpointServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVpcEndpointServiceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
+			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeZonesResult> DescribeZonesOutcome;
+			typedef std::future<DescribeZonesOutcome> DescribeZonesOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::DescribeZonesRequest&, const DescribeZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeZonesAsyncHandler;
+			typedef Outcome<Error, Model::DetachResourceFromVpcEndpointServiceResult> DetachResourceFromVpcEndpointServiceOutcome;
+			typedef std::future<DetachResourceFromVpcEndpointServiceOutcome> DetachResourceFromVpcEndpointServiceOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::DetachResourceFromVpcEndpointServiceRequest&, const DetachResourceFromVpcEndpointServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachResourceFromVpcEndpointServiceAsyncHandler;
+			typedef Outcome<Error, Model::DetachSecurityGroupFromVpcEndpointResult> DetachSecurityGroupFromVpcEndpointOutcome;
+			typedef std::future<DetachSecurityGroupFromVpcEndpointOutcome> DetachSecurityGroupFromVpcEndpointOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::DetachSecurityGroupFromVpcEndpointRequest&, const DetachSecurityGroupFromVpcEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachSecurityGroupFromVpcEndpointAsyncHandler;
+			typedef Outcome<Error, Model::DisableVpcEndpointConnectionResult> DisableVpcEndpointConnectionOutcome;
+			typedef std::future<DisableVpcEndpointConnectionOutcome> DisableVpcEndpointConnectionOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::DisableVpcEndpointConnectionRequest&, const DisableVpcEndpointConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableVpcEndpointConnectionAsyncHandler;
+			typedef Outcome<Error, Model::EnableVpcEndpointConnectionResult> EnableVpcEndpointConnectionOutcome;
+			typedef std::future<EnableVpcEndpointConnectionOutcome> EnableVpcEndpointConnectionOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::EnableVpcEndpointConnectionRequest&, const EnableVpcEndpointConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableVpcEndpointConnectionAsyncHandler;
+			typedef Outcome<Error, Model::GetVpcEndpointAttributeResult> GetVpcEndpointAttributeOutcome;
+			typedef std::future<GetVpcEndpointAttributeOutcome> GetVpcEndpointAttributeOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::GetVpcEndpointAttributeRequest&, const GetVpcEndpointAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVpcEndpointAttributeAsyncHandler;
+			typedef Outcome<Error, Model::GetVpcEndpointServiceAttributeResult> GetVpcEndpointServiceAttributeOutcome;
+			typedef std::future<GetVpcEndpointServiceAttributeOutcome> GetVpcEndpointServiceAttributeOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::GetVpcEndpointServiceAttributeRequest&, const GetVpcEndpointServiceAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVpcEndpointServiceAttributeAsyncHandler;
+			typedef Outcome<Error, Model::ListVpcEndpointConnectionsResult> ListVpcEndpointConnectionsOutcome;
+			typedef std::future<ListVpcEndpointConnectionsOutcome> ListVpcEndpointConnectionsOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointConnectionsRequest&, const ListVpcEndpointConnectionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointConnectionsAsyncHandler;
+			typedef Outcome<Error, Model::ListVpcEndpointSecurityGroupsResult> ListVpcEndpointSecurityGroupsOutcome;
+			typedef std::future<ListVpcEndpointSecurityGroupsOutcome> ListVpcEndpointSecurityGroupsOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointSecurityGroupsRequest&, const ListVpcEndpointSecurityGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointSecurityGroupsAsyncHandler;
+			typedef Outcome<Error, Model::ListVpcEndpointServiceResourcesResult> ListVpcEndpointServiceResourcesOutcome;
+			typedef std::future<ListVpcEndpointServiceResourcesOutcome> ListVpcEndpointServiceResourcesOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointServiceResourcesRequest&, const ListVpcEndpointServiceResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointServiceResourcesAsyncHandler;
+			typedef Outcome<Error, Model::ListVpcEndpointServiceUsersResult> ListVpcEndpointServiceUsersOutcome;
+			typedef std::future<ListVpcEndpointServiceUsersOutcome> ListVpcEndpointServiceUsersOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointServiceUsersRequest&, const ListVpcEndpointServiceUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointServiceUsersAsyncHandler;
+			typedef Outcome<Error, Model::ListVpcEndpointServicesResult> ListVpcEndpointServicesOutcome;
+			typedef std::future<ListVpcEndpointServicesOutcome> ListVpcEndpointServicesOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointServicesRequest&, const ListVpcEndpointServicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointServicesAsyncHandler;
+			typedef Outcome<Error, Model::ListVpcEndpointServicesByEndUserResult> ListVpcEndpointServicesByEndUserOutcome;
+			typedef std::future<ListVpcEndpointServicesByEndUserOutcome> ListVpcEndpointServicesByEndUserOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointServicesByEndUserRequest&, const ListVpcEndpointServicesByEndUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointServicesByEndUserAsyncHandler;
+			typedef Outcome<Error, Model::ListVpcEndpointZonesResult> ListVpcEndpointZonesOutcome;
+			typedef std::future<ListVpcEndpointZonesOutcome> ListVpcEndpointZonesOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointZonesRequest&, const ListVpcEndpointZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointZonesAsyncHandler;
+			typedef Outcome<Error, Model::ListVpcEndpointsResult> ListVpcEndpointsOutcome;
+			typedef std::future<ListVpcEndpointsOutcome> ListVpcEndpointsOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointsRequest&, const ListVpcEndpointsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointsAsyncHandler;
+			typedef Outcome<Error, Model::OpenPrivateLinkServiceResult> OpenPrivateLinkServiceOutcome;
+			typedef std::future<OpenPrivateLinkServiceOutcome> OpenPrivateLinkServiceOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::OpenPrivateLinkServiceRequest&, const OpenPrivateLinkServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> OpenPrivateLinkServiceAsyncHandler;
+			typedef Outcome<Error, Model::RemoveUserFromVpcEndpointServiceResult> RemoveUserFromVpcEndpointServiceOutcome;
+			typedef std::future<RemoveUserFromVpcEndpointServiceOutcome> RemoveUserFromVpcEndpointServiceOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::RemoveUserFromVpcEndpointServiceRequest&, const RemoveUserFromVpcEndpointServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveUserFromVpcEndpointServiceAsyncHandler;
+			typedef Outcome<Error, Model::RemoveZoneFromVpcEndpointResult> RemoveZoneFromVpcEndpointOutcome;
+			typedef std::future<RemoveZoneFromVpcEndpointOutcome> RemoveZoneFromVpcEndpointOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::RemoveZoneFromVpcEndpointRequest&, const RemoveZoneFromVpcEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveZoneFromVpcEndpointAsyncHandler;
+			typedef Outcome<Error, Model::UpdateVpcEndpointAttributeResult> UpdateVpcEndpointAttributeOutcome;
+			typedef std::future<UpdateVpcEndpointAttributeOutcome> UpdateVpcEndpointAttributeOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::UpdateVpcEndpointAttributeRequest&, const UpdateVpcEndpointAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateVpcEndpointAttributeAsyncHandler;
+			typedef Outcome<Error, Model::UpdateVpcEndpointConnectionAttributeResult> UpdateVpcEndpointConnectionAttributeOutcome;
+			typedef std::future<UpdateVpcEndpointConnectionAttributeOutcome> UpdateVpcEndpointConnectionAttributeOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::UpdateVpcEndpointConnectionAttributeRequest&, const UpdateVpcEndpointConnectionAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateVpcEndpointConnectionAttributeAsyncHandler;
+			typedef Outcome<Error, Model::UpdateVpcEndpointServiceAttributeResult> UpdateVpcEndpointServiceAttributeOutcome;
+			typedef std::future<UpdateVpcEndpointServiceAttributeOutcome> UpdateVpcEndpointServiceAttributeOutcomeCallable;
+			typedef std::function<void(const PrivatelinkClient*, const Model::UpdateVpcEndpointServiceAttributeRequest&, const UpdateVpcEndpointServiceAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateVpcEndpointServiceAttributeAsyncHandler;
+
+			PrivatelinkClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			PrivatelinkClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			PrivatelinkClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~PrivatelinkClient();
+			AddUserToVpcEndpointServiceOutcome addUserToVpcEndpointService(const Model::AddUserToVpcEndpointServiceRequest &request)const;
+			void addUserToVpcEndpointServiceAsync(const Model::AddUserToVpcEndpointServiceRequest& request, const AddUserToVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddUserToVpcEndpointServiceOutcomeCallable addUserToVpcEndpointServiceCallable(const Model::AddUserToVpcEndpointServiceRequest& request) const;
+			AddZoneToVpcEndpointOutcome addZoneToVpcEndpoint(const Model::AddZoneToVpcEndpointRequest &request)const;
+			void addZoneToVpcEndpointAsync(const Model::AddZoneToVpcEndpointRequest& request, const AddZoneToVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddZoneToVpcEndpointOutcomeCallable addZoneToVpcEndpointCallable(const Model::AddZoneToVpcEndpointRequest& request) const;
+			AttachResourceToVpcEndpointServiceOutcome attachResourceToVpcEndpointService(const Model::AttachResourceToVpcEndpointServiceRequest &request)const;
+			void attachResourceToVpcEndpointServiceAsync(const Model::AttachResourceToVpcEndpointServiceRequest& request, const AttachResourceToVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AttachResourceToVpcEndpointServiceOutcomeCallable attachResourceToVpcEndpointServiceCallable(const Model::AttachResourceToVpcEndpointServiceRequest& request) const;
+			AttachSecurityGroupToVpcEndpointOutcome attachSecurityGroupToVpcEndpoint(const Model::AttachSecurityGroupToVpcEndpointRequest &request)const;
+			void attachSecurityGroupToVpcEndpointAsync(const Model::AttachSecurityGroupToVpcEndpointRequest& request, const AttachSecurityGroupToVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AttachSecurityGroupToVpcEndpointOutcomeCallable attachSecurityGroupToVpcEndpointCallable(const Model::AttachSecurityGroupToVpcEndpointRequest& request) const;
+			CreateVpcEndpointOutcome createVpcEndpoint(const Model::CreateVpcEndpointRequest &request)const;
+			void createVpcEndpointAsync(const Model::CreateVpcEndpointRequest& request, const CreateVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateVpcEndpointOutcomeCallable createVpcEndpointCallable(const Model::CreateVpcEndpointRequest& request) const;
+			CreateVpcEndpointServiceOutcome createVpcEndpointService(const Model::CreateVpcEndpointServiceRequest &request)const;
+			void createVpcEndpointServiceAsync(const Model::CreateVpcEndpointServiceRequest& request, const CreateVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateVpcEndpointServiceOutcomeCallable createVpcEndpointServiceCallable(const Model::CreateVpcEndpointServiceRequest& request) const;
+			DeleteVpcEndpointOutcome deleteVpcEndpoint(const Model::DeleteVpcEndpointRequest &request)const;
+			void deleteVpcEndpointAsync(const Model::DeleteVpcEndpointRequest& request, const DeleteVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteVpcEndpointOutcomeCallable deleteVpcEndpointCallable(const Model::DeleteVpcEndpointRequest& request) const;
+			DeleteVpcEndpointServiceOutcome deleteVpcEndpointService(const Model::DeleteVpcEndpointServiceRequest &request)const;
+			void deleteVpcEndpointServiceAsync(const Model::DeleteVpcEndpointServiceRequest& request, const DeleteVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteVpcEndpointServiceOutcomeCallable deleteVpcEndpointServiceCallable(const Model::DeleteVpcEndpointServiceRequest& request) const;
+			DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
+			void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
+			DescribeZonesOutcome describeZones(const Model::DescribeZonesRequest &request)const;
+			void describeZonesAsync(const Model::DescribeZonesRequest& request, const DescribeZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeZonesOutcomeCallable describeZonesCallable(const Model::DescribeZonesRequest& request) const;
+			DetachResourceFromVpcEndpointServiceOutcome detachResourceFromVpcEndpointService(const Model::DetachResourceFromVpcEndpointServiceRequest &request)const;
+			void detachResourceFromVpcEndpointServiceAsync(const Model::DetachResourceFromVpcEndpointServiceRequest& request, const DetachResourceFromVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetachResourceFromVpcEndpointServiceOutcomeCallable detachResourceFromVpcEndpointServiceCallable(const Model::DetachResourceFromVpcEndpointServiceRequest& request) const;
+			DetachSecurityGroupFromVpcEndpointOutcome detachSecurityGroupFromVpcEndpoint(const Model::DetachSecurityGroupFromVpcEndpointRequest &request)const;
+			void detachSecurityGroupFromVpcEndpointAsync(const Model::DetachSecurityGroupFromVpcEndpointRequest& request, const DetachSecurityGroupFromVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetachSecurityGroupFromVpcEndpointOutcomeCallable detachSecurityGroupFromVpcEndpointCallable(const Model::DetachSecurityGroupFromVpcEndpointRequest& request) const;
+			DisableVpcEndpointConnectionOutcome disableVpcEndpointConnection(const Model::DisableVpcEndpointConnectionRequest &request)const;
+			void disableVpcEndpointConnectionAsync(const Model::DisableVpcEndpointConnectionRequest& request, const DisableVpcEndpointConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisableVpcEndpointConnectionOutcomeCallable disableVpcEndpointConnectionCallable(const Model::DisableVpcEndpointConnectionRequest& request) const;
+			EnableVpcEndpointConnectionOutcome enableVpcEndpointConnection(const Model::EnableVpcEndpointConnectionRequest &request)const;
+			void enableVpcEndpointConnectionAsync(const Model::EnableVpcEndpointConnectionRequest& request, const EnableVpcEndpointConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableVpcEndpointConnectionOutcomeCallable enableVpcEndpointConnectionCallable(const Model::EnableVpcEndpointConnectionRequest& request) const;
+			GetVpcEndpointAttributeOutcome getVpcEndpointAttribute(const Model::GetVpcEndpointAttributeRequest &request)const;
+			void getVpcEndpointAttributeAsync(const Model::GetVpcEndpointAttributeRequest& request, const GetVpcEndpointAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVpcEndpointAttributeOutcomeCallable getVpcEndpointAttributeCallable(const Model::GetVpcEndpointAttributeRequest& request) const;
+			GetVpcEndpointServiceAttributeOutcome getVpcEndpointServiceAttribute(const Model::GetVpcEndpointServiceAttributeRequest &request)const;
+			void getVpcEndpointServiceAttributeAsync(const Model::GetVpcEndpointServiceAttributeRequest& request, const GetVpcEndpointServiceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVpcEndpointServiceAttributeOutcomeCallable getVpcEndpointServiceAttributeCallable(const Model::GetVpcEndpointServiceAttributeRequest& request) const;
+			ListVpcEndpointConnectionsOutcome listVpcEndpointConnections(const Model::ListVpcEndpointConnectionsRequest &request)const;
+			void listVpcEndpointConnectionsAsync(const Model::ListVpcEndpointConnectionsRequest& request, const ListVpcEndpointConnectionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVpcEndpointConnectionsOutcomeCallable listVpcEndpointConnectionsCallable(const Model::ListVpcEndpointConnectionsRequest& request) const;
+			ListVpcEndpointSecurityGroupsOutcome listVpcEndpointSecurityGroups(const Model::ListVpcEndpointSecurityGroupsRequest &request)const;
+			void listVpcEndpointSecurityGroupsAsync(const Model::ListVpcEndpointSecurityGroupsRequest& request, const ListVpcEndpointSecurityGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVpcEndpointSecurityGroupsOutcomeCallable listVpcEndpointSecurityGroupsCallable(const Model::ListVpcEndpointSecurityGroupsRequest& request) const;
+			ListVpcEndpointServiceResourcesOutcome listVpcEndpointServiceResources(const Model::ListVpcEndpointServiceResourcesRequest &request)const;
+			void listVpcEndpointServiceResourcesAsync(const Model::ListVpcEndpointServiceResourcesRequest& request, const ListVpcEndpointServiceResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVpcEndpointServiceResourcesOutcomeCallable listVpcEndpointServiceResourcesCallable(const Model::ListVpcEndpointServiceResourcesRequest& request) const;
+			ListVpcEndpointServiceUsersOutcome listVpcEndpointServiceUsers(const Model::ListVpcEndpointServiceUsersRequest &request)const;
+			void listVpcEndpointServiceUsersAsync(const Model::ListVpcEndpointServiceUsersRequest& request, const ListVpcEndpointServiceUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVpcEndpointServiceUsersOutcomeCallable listVpcEndpointServiceUsersCallable(const Model::ListVpcEndpointServiceUsersRequest& request) const;
+			ListVpcEndpointServicesOutcome listVpcEndpointServices(const Model::ListVpcEndpointServicesRequest &request)const;
+			void listVpcEndpointServicesAsync(const Model::ListVpcEndpointServicesRequest& request, const ListVpcEndpointServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVpcEndpointServicesOutcomeCallable listVpcEndpointServicesCallable(const Model::ListVpcEndpointServicesRequest& request) const;
+			ListVpcEndpointServicesByEndUserOutcome listVpcEndpointServicesByEndUser(const Model::ListVpcEndpointServicesByEndUserRequest &request)const;
+			void listVpcEndpointServicesByEndUserAsync(const Model::ListVpcEndpointServicesByEndUserRequest& request, const ListVpcEndpointServicesByEndUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVpcEndpointServicesByEndUserOutcomeCallable listVpcEndpointServicesByEndUserCallable(const Model::ListVpcEndpointServicesByEndUserRequest& request) const;
+			ListVpcEndpointZonesOutcome listVpcEndpointZones(const Model::ListVpcEndpointZonesRequest &request)const;
+			void listVpcEndpointZonesAsync(const Model::ListVpcEndpointZonesRequest& request, const ListVpcEndpointZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVpcEndpointZonesOutcomeCallable listVpcEndpointZonesCallable(const Model::ListVpcEndpointZonesRequest& request) const;
+			ListVpcEndpointsOutcome listVpcEndpoints(const Model::ListVpcEndpointsRequest &request)const;
+			void listVpcEndpointsAsync(const Model::ListVpcEndpointsRequest& request, const ListVpcEndpointsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVpcEndpointsOutcomeCallable listVpcEndpointsCallable(const Model::ListVpcEndpointsRequest& request) const;
+			OpenPrivateLinkServiceOutcome openPrivateLinkService(const Model::OpenPrivateLinkServiceRequest &request)const;
+			void openPrivateLinkServiceAsync(const Model::OpenPrivateLinkServiceRequest& request, const OpenPrivateLinkServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			OpenPrivateLinkServiceOutcomeCallable openPrivateLinkServiceCallable(const Model::OpenPrivateLinkServiceRequest& request) const;
+			RemoveUserFromVpcEndpointServiceOutcome removeUserFromVpcEndpointService(const Model::RemoveUserFromVpcEndpointServiceRequest &request)const;
+			void removeUserFromVpcEndpointServiceAsync(const Model::RemoveUserFromVpcEndpointServiceRequest& request, const RemoveUserFromVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveUserFromVpcEndpointServiceOutcomeCallable removeUserFromVpcEndpointServiceCallable(const Model::RemoveUserFromVpcEndpointServiceRequest& request) const;
+			RemoveZoneFromVpcEndpointOutcome removeZoneFromVpcEndpoint(const Model::RemoveZoneFromVpcEndpointRequest &request)const;
+			void removeZoneFromVpcEndpointAsync(const Model::RemoveZoneFromVpcEndpointRequest& request, const RemoveZoneFromVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveZoneFromVpcEndpointOutcomeCallable removeZoneFromVpcEndpointCallable(const Model::RemoveZoneFromVpcEndpointRequest& request) const;
+			UpdateVpcEndpointAttributeOutcome updateVpcEndpointAttribute(const Model::UpdateVpcEndpointAttributeRequest &request)const;
+			void updateVpcEndpointAttributeAsync(const Model::UpdateVpcEndpointAttributeRequest& request, const UpdateVpcEndpointAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateVpcEndpointAttributeOutcomeCallable updateVpcEndpointAttributeCallable(const Model::UpdateVpcEndpointAttributeRequest& request) const;
+			UpdateVpcEndpointConnectionAttributeOutcome updateVpcEndpointConnectionAttribute(const Model::UpdateVpcEndpointConnectionAttributeRequest &request)const;
+			void updateVpcEndpointConnectionAttributeAsync(const Model::UpdateVpcEndpointConnectionAttributeRequest& request, const UpdateVpcEndpointConnectionAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateVpcEndpointConnectionAttributeOutcomeCallable updateVpcEndpointConnectionAttributeCallable(const Model::UpdateVpcEndpointConnectionAttributeRequest& request) const;
+			UpdateVpcEndpointServiceAttributeOutcome updateVpcEndpointServiceAttribute(const Model::UpdateVpcEndpointServiceAttributeRequest &request)const;
+			void updateVpcEndpointServiceAttributeAsync(const Model::UpdateVpcEndpointServiceAttributeRequest& request, const UpdateVpcEndpointServiceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateVpcEndpointServiceAttributeOutcomeCallable updateVpcEndpointServiceAttributeCallable(const Model::UpdateVpcEndpointServiceAttributeRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_PRIVATELINK_PRIVATELINKCLIENT_H_

privatelink/include/alibabacloud/privatelink/PrivatelinkExport.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_PRIVATELINK_PRIVATELINKEXPORT_H_
+#define ALIBABACLOUD_PRIVATELINK_PRIVATELINKEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_PRIVATELINK_LIBRARY)
+#		define ALIBABACLOUD_PRIVATELINK_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_PRIVATELINK_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_PRIVATELINK_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_PRIVATELINK_PRIVATELINKEXPORT_H_

privatelink/include/alibabacloud/privatelink/model/AddUserToVpcEndpointServiceRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_ADDUSERTOVPCENDPOINTSERVICEREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_ADDUSERTOVPCENDPOINTSERVICEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT AddUserToVpcEndpointServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddUserToVpcEndpointServiceRequest();
+				~AddUserToVpcEndpointServiceRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getUserId()const;
+				void setUserId(const std::string& userId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				std::string clientToken_;
+				std::string userId_;
+				std::string regionId_;
+				bool dryRun_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ADDUSERTOVPCENDPOINTSERVICEREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/AddUserToVpcEndpointServiceResult.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_PRIVATELINK_MODEL_ADDUSERTOVPCENDPOINTSERVICERESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_ADDUSERTOVPCENDPOINTSERVICERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT AddUserToVpcEndpointServiceResult : public ServiceResult
+			{
+			public:
+
+
+				AddUserToVpcEndpointServiceResult();
+				explicit AddUserToVpcEndpointServiceResult(const std::string &payload);
+				~AddUserToVpcEndpointServiceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ADDUSERTOVPCENDPOINTSERVICERESULT_H_

privatelink/include/alibabacloud/privatelink/model/AddZoneToVpcEndpointRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT AddZoneToVpcEndpointRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddZoneToVpcEndpointRequest();
+				~AddZoneToVpcEndpointRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getEndpointId()const;
+				void setEndpointId(const std::string& endpointId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+				std::string getVSwitchId()const;
+				void setVSwitchId(const std::string& vSwitchId);
+				std::string getZoneId()const;
+				void setZoneId(const std::string& zoneId);
+
+            private:
+				std::string clientToken_;
+				std::string endpointId_;
+				std::string regionId_;
+				bool dryRun_;
+				std::string vSwitchId_;
+				std::string zoneId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/AddZoneToVpcEndpointResult.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_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT AddZoneToVpcEndpointResult : public ServiceResult
+			{
+			public:
+
+
+				AddZoneToVpcEndpointResult();
+				explicit AddZoneToVpcEndpointResult(const std::string &payload);
+				~AddZoneToVpcEndpointResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTRESULT_H_

privatelink/include/alibabacloud/privatelink/model/AttachResourceToVpcEndpointServiceRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHRESOURCETOVPCENDPOINTSERVICEREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHRESOURCETOVPCENDPOINTSERVICEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT AttachResourceToVpcEndpointServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				AttachResourceToVpcEndpointServiceRequest();
+				~AttachResourceToVpcEndpointServiceRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getResourceId()const;
+				void setResourceId(const std::string& resourceId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+				std::string getResourceType()const;
+				void setResourceType(const std::string& resourceType);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				std::string clientToken_;
+				std::string regionId_;
+				std::string resourceId_;
+				bool dryRun_;
+				std::string resourceType_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHRESOURCETOVPCENDPOINTSERVICEREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/AttachResourceToVpcEndpointServiceResult.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_PRIVATELINK_MODEL_ATTACHRESOURCETOVPCENDPOINTSERVICERESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHRESOURCETOVPCENDPOINTSERVICERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT AttachResourceToVpcEndpointServiceResult : public ServiceResult
+			{
+			public:
+
+
+				AttachResourceToVpcEndpointServiceResult();
+				explicit AttachResourceToVpcEndpointServiceResult(const std::string &payload);
+				~AttachResourceToVpcEndpointServiceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHRESOURCETOVPCENDPOINTSERVICERESULT_H_

privatelink/include/alibabacloud/privatelink/model/AttachSecurityGroupToVpcEndpointRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHSECURITYGROUPTOVPCENDPOINTREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHSECURITYGROUPTOVPCENDPOINTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT AttachSecurityGroupToVpcEndpointRequest : public RpcServiceRequest
+			{
+
+			public:
+				AttachSecurityGroupToVpcEndpointRequest();
+				~AttachSecurityGroupToVpcEndpointRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getEndpointId()const;
+				void setEndpointId(const std::string& endpointId);
+				std::string getSecurityGroupId()const;
+				void setSecurityGroupId(const std::string& securityGroupId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+
+            private:
+				std::string clientToken_;
+				std::string endpointId_;
+				std::string securityGroupId_;
+				std::string regionId_;
+				bool dryRun_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHSECURITYGROUPTOVPCENDPOINTREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/AttachSecurityGroupToVpcEndpointResult.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_PRIVATELINK_MODEL_ATTACHSECURITYGROUPTOVPCENDPOINTRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHSECURITYGROUPTOVPCENDPOINTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT AttachSecurityGroupToVpcEndpointResult : public ServiceResult
+			{
+			public:
+
+
+				AttachSecurityGroupToVpcEndpointResult();
+				explicit AttachSecurityGroupToVpcEndpointResult(const std::string &payload);
+				~AttachSecurityGroupToVpcEndpointResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHSECURITYGROUPTOVPCENDPOINTRESULT_H_

privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointRequest.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT CreateVpcEndpointRequest : public RpcServiceRequest
+			{
+			public:
+				struct Zone
+				{
+					std::string vSwitchId;
+					std::string zoneId;
+				};
+
+			public:
+				CreateVpcEndpointRequest();
+				~CreateVpcEndpointRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::vector<std::string> getSecurityGroupId()const;
+				void setSecurityGroupId(const std::vector<std::string>& securityGroupId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::vector<Zone> getZone()const;
+				void setZone(const std::vector<Zone>& zone);
+				std::string getServiceName()const;
+				void setServiceName(const std::string& serviceName);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+				std::string getEndpointDescription()const;
+				void setEndpointDescription(const std::string& endpointDescription);
+				std::string getEndpointName()const;
+				void setEndpointName(const std::string& endpointName);
+				std::string getVpcId()const;
+				void setVpcId(const std::string& vpcId);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				std::string clientToken_;
+				std::vector<std::string> securityGroupId_;
+				std::string regionId_;
+				std::vector<Zone> zone_;
+				std::string serviceName_;
+				bool dryRun_;
+				std::string endpointDescription_;
+				std::string endpointName_;
+				std::string vpcId_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT CreateVpcEndpointResult : public ServiceResult
+			{
+			public:
+
+
+				CreateVpcEndpointResult();
+				explicit CreateVpcEndpointResult(const std::string &payload);
+				~CreateVpcEndpointResult();
+				std::string getEndpointStatus()const;
+				std::string getEndpointName()const;
+				std::string getVpcId()const;
+				std::string getEndpointDomain()const;
+				std::string getServiceName()const;
+				std::string getEndpointId()const;
+				std::string getCreateTime()const;
+				long getBandwidth()const;
+				std::string getEndpointBusinessStatus()const;
+				std::string getEndpointDescription()const;
+				std::string getConnectionStatus()const;
+				std::string getServiceId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string endpointStatus_;
+				std::string endpointName_;
+				std::string vpcId_;
+				std::string endpointDomain_;
+				std::string serviceName_;
+				std::string endpointId_;
+				std::string createTime_;
+				long bandwidth_;
+				std::string endpointBusinessStatus_;
+				std::string endpointDescription_;
+				std::string connectionStatus_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTRESULT_H_

privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointServiceRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICEREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT CreateVpcEndpointServiceRequest : public RpcServiceRequest
+			{
+			public:
+				struct Resource
+				{
+					std::string resourceId;
+					std::string resourceType;
+				};
+
+			public:
+				CreateVpcEndpointServiceRequest();
+				~CreateVpcEndpointServiceRequest();
+
+				bool getAutoAcceptEnabled()const;
+				void setAutoAcceptEnabled(bool autoAcceptEnabled);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getPayer()const;
+				void setPayer(const std::string& payer);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+				std::vector<Resource> getResource()const;
+				void setResource(const std::vector<Resource>& resource);
+				std::string getServiceDescription()const;
+				void setServiceDescription(const std::string& serviceDescription);
+
+            private:
+				bool autoAcceptEnabled_;
+				std::string clientToken_;
+				std::string payer_;
+				std::string regionId_;
+				bool dryRun_;
+				std::vector<Resource> resource_;
+				std::string serviceDescription_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICEREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointServiceResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICERESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT CreateVpcEndpointServiceResult : public ServiceResult
+			{
+			public:
+
+
+				CreateVpcEndpointServiceResult();
+				explicit CreateVpcEndpointServiceResult(const std::string &payload);
+				~CreateVpcEndpointServiceResult();
+				std::string getServiceBusinessStatus()const;
+				std::string getServiceName()const;
+				std::string getServiceDescription()const;
+				std::string getServiceStatus()const;
+				std::string getCreateTime()const;
+				std::string getServiceDomain()const;
+				bool getAutoAcceptEnabled()const;
+				std::string getServiceId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string serviceBusinessStatus_;
+				std::string serviceName_;
+				std::string serviceDescription_;
+				std::string serviceStatus_;
+				std::string createTime_;
+				std::string serviceDomain_;
+				bool autoAcceptEnabled_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICERESULT_H_

privatelink/include/alibabacloud/privatelink/model/DeleteVpcEndpointRequest.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_PRIVATELINK_MODEL_DELETEVPCENDPOINTREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT DeleteVpcEndpointRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteVpcEndpointRequest();
+				~DeleteVpcEndpointRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getEndpointId()const;
+				void setEndpointId(const std::string& endpointId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+
+            private:
+				std::string clientToken_;
+				std::string endpointId_;
+				std::string regionId_;
+				bool dryRun_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/DeleteVpcEndpointResult.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_PRIVATELINK_MODEL_DELETEVPCENDPOINTRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT DeleteVpcEndpointResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteVpcEndpointResult();
+				explicit DeleteVpcEndpointResult(const std::string &payload);
+				~DeleteVpcEndpointResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTRESULT_H_

privatelink/include/alibabacloud/privatelink/model/DeleteVpcEndpointServiceRequest.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_PRIVATELINK_MODEL_DELETEVPCENDPOINTSERVICEREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTSERVICEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT DeleteVpcEndpointServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteVpcEndpointServiceRequest();
+				~DeleteVpcEndpointServiceRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				std::string clientToken_;
+				std::string regionId_;
+				bool dryRun_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTSERVICEREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/DeleteVpcEndpointServiceResult.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_PRIVATELINK_MODEL_DELETEVPCENDPOINTSERVICERESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTSERVICERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT DeleteVpcEndpointServiceResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteVpcEndpointServiceResult();
+				explicit DeleteVpcEndpointServiceResult(const std::string &payload);
+				~DeleteVpcEndpointServiceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTSERVICERESULT_H_

privatelink/include/alibabacloud/privatelink/model/DescribeRegionsRequest.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_PRIVATELINK_MODEL_DESCRIBEREGIONSREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEREGIONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT DescribeRegionsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeRegionsRequest();
+				~DescribeRegionsRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+
+            private:
+				std::string regionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEREGIONSREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/DescribeRegionsResult.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_PRIVATELINK_MODEL_DESCRIBEREGIONSRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEREGIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT DescribeRegionsResult : public ServiceResult
+			{
+			public:
+				struct Region
+				{
+					std::string regionId;
+					std::string regionEndpoint;
+					std::string localName;
+				};
+
+
+				DescribeRegionsResult();
+				explicit DescribeRegionsResult(const std::string &payload);
+				~DescribeRegionsResult();
+				std::vector<Region> getRegions()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Region> regions_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEREGIONSRESULT_H_

privatelink/include/alibabacloud/privatelink/model/DescribeZonesRequest.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_PRIVATELINK_MODEL_DESCRIBEZONESREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEZONESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT DescribeZonesRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeZonesRequest();
+				~DescribeZonesRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+
+            private:
+				std::string regionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEZONESREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/DescribeZonesResult.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_PRIVATELINK_MODEL_DESCRIBEZONESRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEZONESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT DescribeZonesResult : public ServiceResult
+			{
+			public:
+				struct Zone
+				{
+					std::string zoneId;
+					std::string localName;
+				};
+
+
+				DescribeZonesResult();
+				explicit DescribeZonesResult(const std::string &payload);
+				~DescribeZonesResult();
+				std::vector<Zone> getZones()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Zone> zones_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEZONESRESULT_H_

privatelink/include/alibabacloud/privatelink/model/DetachResourceFromVpcEndpointServiceRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_DETACHRESOURCEFROMVPCENDPOINTSERVICEREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_DETACHRESOURCEFROMVPCENDPOINTSERVICEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT DetachResourceFromVpcEndpointServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetachResourceFromVpcEndpointServiceRequest();
+				~DetachResourceFromVpcEndpointServiceRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getResourceId()const;
+				void setResourceId(const std::string& resourceId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+				std::string getResourceType()const;
+				void setResourceType(const std::string& resourceType);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				std::string clientToken_;
+				std::string regionId_;
+				std::string resourceId_;
+				bool dryRun_;
+				std::string resourceType_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DETACHRESOURCEFROMVPCENDPOINTSERVICEREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/DetachResourceFromVpcEndpointServiceResult.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_PRIVATELINK_MODEL_DETACHRESOURCEFROMVPCENDPOINTSERVICERESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_DETACHRESOURCEFROMVPCENDPOINTSERVICERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT DetachResourceFromVpcEndpointServiceResult : public ServiceResult
+			{
+			public:
+
+
+				DetachResourceFromVpcEndpointServiceResult();
+				explicit DetachResourceFromVpcEndpointServiceResult(const std::string &payload);
+				~DetachResourceFromVpcEndpointServiceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DETACHRESOURCEFROMVPCENDPOINTSERVICERESULT_H_

privatelink/include/alibabacloud/privatelink/model/DetachSecurityGroupFromVpcEndpointRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_DETACHSECURITYGROUPFROMVPCENDPOINTREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_DETACHSECURITYGROUPFROMVPCENDPOINTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT DetachSecurityGroupFromVpcEndpointRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetachSecurityGroupFromVpcEndpointRequest();
+				~DetachSecurityGroupFromVpcEndpointRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getEndpointId()const;
+				void setEndpointId(const std::string& endpointId);
+				std::string getSecurityGroupId()const;
+				void setSecurityGroupId(const std::string& securityGroupId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+
+            private:
+				std::string clientToken_;
+				std::string endpointId_;
+				std::string securityGroupId_;
+				std::string regionId_;
+				bool dryRun_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DETACHSECURITYGROUPFROMVPCENDPOINTREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/DetachSecurityGroupFromVpcEndpointResult.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_PRIVATELINK_MODEL_DETACHSECURITYGROUPFROMVPCENDPOINTRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_DETACHSECURITYGROUPFROMVPCENDPOINTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT DetachSecurityGroupFromVpcEndpointResult : public ServiceResult
+			{
+			public:
+
+
+				DetachSecurityGroupFromVpcEndpointResult();
+				explicit DetachSecurityGroupFromVpcEndpointResult(const std::string &payload);
+				~DetachSecurityGroupFromVpcEndpointResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DETACHSECURITYGROUPFROMVPCENDPOINTRESULT_H_

privatelink/include/alibabacloud/privatelink/model/DisableVpcEndpointConnectionRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTCONNECTIONREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTCONNECTIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT DisableVpcEndpointConnectionRequest : public RpcServiceRequest
+			{
+
+			public:
+				DisableVpcEndpointConnectionRequest();
+				~DisableVpcEndpointConnectionRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getEndpointId()const;
+				void setEndpointId(const std::string& endpointId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				std::string clientToken_;
+				std::string endpointId_;
+				std::string regionId_;
+				bool dryRun_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTCONNECTIONREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/DisableVpcEndpointConnectionResult.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_PRIVATELINK_MODEL_DISABLEVPCENDPOINTCONNECTIONRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTCONNECTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT DisableVpcEndpointConnectionResult : public ServiceResult
+			{
+			public:
+
+
+				DisableVpcEndpointConnectionResult();
+				explicit DisableVpcEndpointConnectionResult(const std::string &payload);
+				~DisableVpcEndpointConnectionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTCONNECTIONRESULT_H_

privatelink/include/alibabacloud/privatelink/model/EnableVpcEndpointConnectionRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTCONNECTIONREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTCONNECTIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT EnableVpcEndpointConnectionRequest : public RpcServiceRequest
+			{
+
+			public:
+				EnableVpcEndpointConnectionRequest();
+				~EnableVpcEndpointConnectionRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getEndpointId()const;
+				void setEndpointId(const std::string& endpointId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+				int getBandwidth()const;
+				void setBandwidth(int bandwidth);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				std::string clientToken_;
+				std::string endpointId_;
+				std::string regionId_;
+				bool dryRun_;
+				int bandwidth_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTCONNECTIONREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/EnableVpcEndpointConnectionResult.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_PRIVATELINK_MODEL_ENABLEVPCENDPOINTCONNECTIONRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTCONNECTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT EnableVpcEndpointConnectionResult : public ServiceResult
+			{
+			public:
+
+
+				EnableVpcEndpointConnectionResult();
+				explicit EnableVpcEndpointConnectionResult(const std::string &payload);
+				~EnableVpcEndpointConnectionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTCONNECTIONRESULT_H_

privatelink/include/alibabacloud/privatelink/model/GetVpcEndpointAttributeRequest.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_PRIVATELINK_MODEL_GETVPCENDPOINTATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTATTRIBUTEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT GetVpcEndpointAttributeRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetVpcEndpointAttributeRequest();
+				~GetVpcEndpointAttributeRequest();
+
+				std::string getEndpointId()const;
+				void setEndpointId(const std::string& endpointId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+
+            private:
+				std::string endpointId_;
+				std::string regionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTATTRIBUTEREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/GetVpcEndpointAttributeResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTATTRIBUTERESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT GetVpcEndpointAttributeResult : public ServiceResult
+			{
+			public:
+
+
+				GetVpcEndpointAttributeResult();
+				explicit GetVpcEndpointAttributeResult(const std::string &payload);
+				~GetVpcEndpointAttributeResult();
+				std::string getPayer()const;
+				std::string getEndpointDomain()const;
+				std::string getCreateTime()const;
+				bool getResourceOwner()const;
+				std::string getEndpointBusinessStatus()const;
+				std::string getEndpointDescription()const;
+				std::string getServiceId()const;
+				std::string getEndpointStatus()const;
+				std::string getEndpointName()const;
+				std::string getVpcId()const;
+				std::string getServiceName()const;
+				int getBandwidth()const;
+				std::string getEndpointId()const;
+				std::string getRegionId()const;
+				std::string getConnectionStatus()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string payer_;
+				std::string endpointDomain_;
+				std::string createTime_;
+				bool resourceOwner_;
+				std::string endpointBusinessStatus_;
+				std::string endpointDescription_;
+				std::string serviceId_;
+				std::string endpointStatus_;
+				std::string endpointName_;
+				std::string vpcId_;
+				std::string serviceName_;
+				int bandwidth_;
+				std::string endpointId_;
+				std::string regionId_;
+				std::string connectionStatus_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTATTRIBUTERESULT_H_

privatelink/include/alibabacloud/privatelink/model/GetVpcEndpointServiceAttributeRequest.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_PRIVATELINK_MODEL_GETVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT GetVpcEndpointServiceAttributeRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetVpcEndpointServiceAttributeRequest();
+				~GetVpcEndpointServiceAttributeRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				std::string regionId_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/GetVpcEndpointServiceAttributeResult.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTSERVICEATTRIBUTERESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTSERVICEATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT GetVpcEndpointServiceAttributeResult : public ServiceResult
+			{
+			public:
+
+
+				GetVpcEndpointServiceAttributeResult();
+				explicit GetVpcEndpointServiceAttributeResult(const std::string &payload);
+				~GetVpcEndpointServiceAttributeResult();
+				std::string getPayer()const;
+				std::string getServiceDescription()const;
+				std::string getCreateTime()const;
+				int getMaxBandwidth()const;
+				std::string getServiceDomain()const;
+				int getMinBandwidth()const;
+				std::vector<std::string> getZones()const;
+				std::string getServiceId()const;
+				bool getAutoAcceptEnabled()const;
+				std::string getServiceBusinessStatus()const;
+				std::string getServiceName()const;
+				std::string getServiceStatus()const;
+				int getConnectBandwidth()const;
+				std::string getRegionId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string payer_;
+				std::string serviceDescription_;
+				std::string createTime_;
+				int maxBandwidth_;
+				std::string serviceDomain_;
+				int minBandwidth_;
+				std::vector<std::string> zones_;
+				std::string serviceId_;
+				bool autoAcceptEnabled_;
+				std::string serviceBusinessStatus_;
+				std::string serviceName_;
+				std::string serviceStatus_;
+				int connectBandwidth_;
+				std::string regionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTSERVICEATTRIBUTERESULT_H_

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointConnectionsRequest.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_PRIVATELINK_MODEL_LISTVPCENDPOINTCONNECTIONSREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTCONNECTIONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointConnectionsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListVpcEndpointConnectionsRequest();
+				~ListVpcEndpointConnectionsRequest();
+
+				std::string getEndpointId()const;
+				void setEndpointId(const std::string& endpointId);
+				long getEndpointOwnerId()const;
+				void setEndpointOwnerId(long endpointOwnerId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				std::string getConnectionStatus()const;
+				void setConnectionStatus(const std::string& connectionStatus);
+				int getMaxResults()const;
+				void setMaxResults(int maxResults);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				std::string endpointId_;
+				long endpointOwnerId_;
+				std::string regionId_;
+				std::string nextToken_;
+				std::string connectionStatus_;
+				int maxResults_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTCONNECTIONSREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointConnectionsResult.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_PRIVATELINK_MODEL_LISTVPCENDPOINTCONNECTIONSRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTCONNECTIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointConnectionsResult : public ServiceResult
+			{
+			public:
+				struct Connection
+				{
+					struct Zone
+					{
+						std::string zoneId;
+						std::string eniId;
+						std::string resourceId;
+						std::string vSwitchId;
+						std::string zoneDomain;
+					};
+					long endpointOwnerId;
+					std::string modifiedTime;
+					std::string endpointId;
+					int bandwidth;
+					bool resourceOwner;
+					std::string endpointVpcId;
+					std::string connectionStatus;
+					std::vector<Connection::Zone> zones;
+					std::string serviceId;
+				};
+
+
+				ListVpcEndpointConnectionsResult();
+				explicit ListVpcEndpointConnectionsResult(const std::string &payload);
+				~ListVpcEndpointConnectionsResult();
+				std::vector<Connection> getConnections()const;
+				std::string getNextToken()const;
+				std::string getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Connection> connections_;
+				std::string nextToken_;
+				std::string maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTCONNECTIONSRESULT_H_

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointSecurityGroupsRequest.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_PRIVATELINK_MODEL_LISTVPCENDPOINTSECURITYGROUPSREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSECURITYGROUPSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointSecurityGroupsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListVpcEndpointSecurityGroupsRequest();
+				~ListVpcEndpointSecurityGroupsRequest();
+
+				std::string getEndpointId()const;
+				void setEndpointId(const std::string& endpointId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				int getMaxResults()const;
+				void setMaxResults(int maxResults);
+
+            private:
+				std::string endpointId_;
+				std::string regionId_;
+				std::string nextToken_;
+				int maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSECURITYGROUPSREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointSecurityGroupsResult.h

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

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServiceResourcesRequest.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_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICERESOURCESREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICERESOURCESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointServiceResourcesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListVpcEndpointServiceResourcesRequest();
+				~ListVpcEndpointServiceResourcesRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				int getMaxResults()const;
+				void setMaxResults(int maxResults);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				std::string regionId_;
+				std::string nextToken_;
+				int maxResults_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICERESOURCESREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServiceResourcesResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICERESOURCESRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICERESOURCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointServiceResourcesResult : public ServiceResult
+			{
+			public:
+				struct Resource
+				{
+					std::string zoneId;
+					std::string vpcId;
+					std::string resourceId;
+					std::string ip;
+					std::string vSwitchId;
+					std::string resourceType;
+					std::string regionId;
+				};
+
+
+				ListVpcEndpointServiceResourcesResult();
+				explicit ListVpcEndpointServiceResourcesResult(const std::string &payload);
+				~ListVpcEndpointServiceResourcesResult();
+				std::string getNextToken()const;
+				std::string getMaxResults()const;
+				std::vector<Resource> getResources()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::string maxResults_;
+				std::vector<Resource> resources_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICERESOURCESRESULT_H_

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServiceUsersRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICEUSERSREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICEUSERSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointServiceUsersRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListVpcEndpointServiceUsersRequest();
+				~ListVpcEndpointServiceUsersRequest();
+
+				long getUserId()const;
+				void setUserId(long userId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				int getMaxResults()const;
+				void setMaxResults(int maxResults);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				long userId_;
+				std::string regionId_;
+				std::string nextToken_;
+				int maxResults_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICEUSERSREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServiceUsersResult.h

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

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServicesByEndUserRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESBYENDUSERREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESBYENDUSERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointServicesByEndUserRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListVpcEndpointServicesByEndUserRequest();
+				~ListVpcEndpointServicesByEndUserRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				std::string getServiceName()const;
+				void setServiceName(const std::string& serviceName);
+				int getMaxResults()const;
+				void setMaxResults(int maxResults);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				std::string regionId_;
+				std::string nextToken_;
+				std::string serviceName_;
+				int maxResults_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESBYENDUSERREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServicesByEndUserResult.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESBYENDUSERRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESBYENDUSERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointServicesByEndUserResult : public ServiceResult
+			{
+			public:
+				struct Service
+				{
+					std::string payer;
+					std::string serviceName;
+					std::string serviceDomain;
+					std::string serviceId;
+					std::vector<std::string> zones;
+				};
+
+
+				ListVpcEndpointServicesByEndUserResult();
+				explicit ListVpcEndpointServicesByEndUserResult(const std::string &payload);
+				~ListVpcEndpointServicesByEndUserResult();
+				std::vector<Service> getServices()const;
+				std::string getNextToken()const;
+				std::string getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Service> services_;
+				std::string nextToken_;
+				std::string maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESBYENDUSERRESULT_H_

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServicesRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointServicesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListVpcEndpointServicesRequest();
+				~ListVpcEndpointServicesRequest();
+
+				std::string getServiceBusinessStatus()const;
+				void setServiceBusinessStatus(const std::string& serviceBusinessStatus);
+				bool getAutoAcceptEnabled()const;
+				void setAutoAcceptEnabled(bool autoAcceptEnabled);
+				std::string getServiceStatus()const;
+				void setServiceStatus(const std::string& serviceStatus);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				std::string getServiceName()const;
+				void setServiceName(const std::string& serviceName);
+				int getMaxResults()const;
+				void setMaxResults(int maxResults);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				std::string serviceBusinessStatus_;
+				bool autoAcceptEnabled_;
+				std::string serviceStatus_;
+				std::string regionId_;
+				std::string nextToken_;
+				std::string serviceName_;
+				int maxResults_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServicesResult.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointServicesResult : public ServiceResult
+			{
+			public:
+				struct Service
+				{
+					std::string payer;
+					std::string serviceDescription;
+					std::string createTime;
+					int maxBandwidth;
+					int minBandwidth;
+					std::string serviceDomain;
+					bool autoAcceptEnabled;
+					std::string serviceId;
+					std::string serviceBusinessStatus;
+					std::string serviceName;
+					std::string serviceStatus;
+					int connectBandwidth;
+					std::string regionId;
+				};
+
+
+				ListVpcEndpointServicesResult();
+				explicit ListVpcEndpointServicesResult(const std::string &payload);
+				~ListVpcEndpointServicesResult();
+				std::vector<Service> getServices()const;
+				std::string getNextToken()const;
+				std::string getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Service> services_;
+				std::string nextToken_;
+				std::string maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESRESULT_H_

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointZonesRequest.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_PRIVATELINK_MODEL_LISTVPCENDPOINTZONESREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTZONESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointZonesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListVpcEndpointZonesRequest();
+				~ListVpcEndpointZonesRequest();
+
+				std::string getEndpointId()const;
+				void setEndpointId(const std::string& endpointId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				int getMaxResults()const;
+				void setMaxResults(int maxResults);
+
+            private:
+				std::string endpointId_;
+				std::string regionId_;
+				std::string nextToken_;
+				int maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTZONESREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointZonesResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTZONESRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTZONESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointZonesResult : public ServiceResult
+			{
+			public:
+				struct Zone
+				{
+					std::string eniId;
+					std::string zoneId;
+					std::string vSwitchId;
+					std::string eniIp;
+					std::string zoneStatus;
+					std::string regionId;
+					std::string zoneDomain;
+				};
+
+
+				ListVpcEndpointZonesResult();
+				explicit ListVpcEndpointZonesResult(const std::string &payload);
+				~ListVpcEndpointZonesResult();
+				std::string getNextToken()const;
+				std::string getMaxResults()const;
+				std::vector<Zone> getZones()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::string maxResults_;
+				std::vector<Zone> zones_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTZONESRESULT_H_

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointsRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListVpcEndpointsRequest();
+				~ListVpcEndpointsRequest();
+
+				std::string getEndpointId()const;
+				void setEndpointId(const std::string& endpointId);
+				std::string getEndpointStatus()const;
+				void setEndpointStatus(const std::string& endpointStatus);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				std::string getServiceName()const;
+				void setServiceName(const std::string& serviceName);
+				std::string getConnectionStatus()const;
+				void setConnectionStatus(const std::string& connectionStatus);
+				std::string getVpcId()const;
+				void setVpcId(const std::string& vpcId);
+				std::string getEndpointName()const;
+				void setEndpointName(const std::string& endpointName);
+				int getMaxResults()const;
+				void setMaxResults(int maxResults);
+
+            private:
+				std::string endpointId_;
+				std::string endpointStatus_;
+				std::string regionId_;
+				std::string nextToken_;
+				std::string serviceName_;
+				std::string connectionStatus_;
+				std::string vpcId_;
+				std::string endpointName_;
+				int maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointsResult.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointsResult : public ServiceResult
+			{
+			public:
+				struct Endpoint
+				{
+					std::string endpointDomain;
+					std::string createTime;
+					bool resourceOwner;
+					std::string endpointBusinessStatus;
+					std::string endpointDescription;
+					std::string serviceId;
+					std::string endpointStatus;
+					std::string endpointName;
+					std::string vpcId;
+					std::string serviceName;
+					std::string endpointId;
+					long bandwidth;
+					std::string regionId;
+					std::string connectionStatus;
+				};
+
+
+				ListVpcEndpointsResult();
+				explicit ListVpcEndpointsResult(const std::string &payload);
+				~ListVpcEndpointsResult();
+				std::vector<Endpoint> getEndpoints()const;
+				std::string getNextToken()const;
+				std::string getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Endpoint> endpoints_;
+				std::string nextToken_;
+				std::string maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSRESULT_H_

privatelink/include/alibabacloud/privatelink/model/OpenPrivateLinkServiceRequest.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_PRIVATELINK_MODEL_OPENPRIVATELINKSERVICEREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_OPENPRIVATELINKSERVICEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT OpenPrivateLinkServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				OpenPrivateLinkServiceRequest();
+				~OpenPrivateLinkServiceRequest();
+
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_OPENPRIVATELINKSERVICEREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/OpenPrivateLinkServiceResult.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_PRIVATELINK_MODEL_OPENPRIVATELINKSERVICERESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_OPENPRIVATELINKSERVICERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT OpenPrivateLinkServiceResult : public ServiceResult
+			{
+			public:
+
+
+				OpenPrivateLinkServiceResult();
+				explicit OpenPrivateLinkServiceResult(const std::string &payload);
+				~OpenPrivateLinkServiceResult();
+				std::string getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_OPENPRIVATELINKSERVICERESULT_H_

privatelink/include/alibabacloud/privatelink/model/RemoveUserFromVpcEndpointServiceRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEUSERFROMVPCENDPOINTSERVICEREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEUSERFROMVPCENDPOINTSERVICEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT RemoveUserFromVpcEndpointServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				RemoveUserFromVpcEndpointServiceRequest();
+				~RemoveUserFromVpcEndpointServiceRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				long getUserId()const;
+				void setUserId(long userId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				std::string clientToken_;
+				long userId_;
+				std::string regionId_;
+				bool dryRun_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEUSERFROMVPCENDPOINTSERVICEREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/RemoveUserFromVpcEndpointServiceResult.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_PRIVATELINK_MODEL_REMOVEUSERFROMVPCENDPOINTSERVICERESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEUSERFROMVPCENDPOINTSERVICERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT RemoveUserFromVpcEndpointServiceResult : public ServiceResult
+			{
+			public:
+
+
+				RemoveUserFromVpcEndpointServiceResult();
+				explicit RemoveUserFromVpcEndpointServiceResult(const std::string &payload);
+				~RemoveUserFromVpcEndpointServiceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEUSERFROMVPCENDPOINTSERVICERESULT_H_

privatelink/include/alibabacloud/privatelink/model/RemoveZoneFromVpcEndpointRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEZONEFROMVPCENDPOINTREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEZONEFROMVPCENDPOINTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT RemoveZoneFromVpcEndpointRequest : public RpcServiceRequest
+			{
+
+			public:
+				RemoveZoneFromVpcEndpointRequest();
+				~RemoveZoneFromVpcEndpointRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getEndpointId()const;
+				void setEndpointId(const std::string& endpointId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+				std::string getZoneId()const;
+				void setZoneId(const std::string& zoneId);
+
+            private:
+				std::string clientToken_;
+				std::string endpointId_;
+				std::string regionId_;
+				bool dryRun_;
+				std::string zoneId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEZONEFROMVPCENDPOINTREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/RemoveZoneFromVpcEndpointResult.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_PRIVATELINK_MODEL_REMOVEZONEFROMVPCENDPOINTRESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEZONEFROMVPCENDPOINTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT RemoveZoneFromVpcEndpointResult : public ServiceResult
+			{
+			public:
+
+
+				RemoveZoneFromVpcEndpointResult();
+				explicit RemoveZoneFromVpcEndpointResult(const std::string &payload);
+				~RemoveZoneFromVpcEndpointResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEZONEFROMVPCENDPOINTRESULT_H_

privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointAttributeRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTATTRIBUTEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointAttributeRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateVpcEndpointAttributeRequest();
+				~UpdateVpcEndpointAttributeRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getEndpointId()const;
+				void setEndpointId(const std::string& endpointId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+				std::string getEndpointDescription()const;
+				void setEndpointDescription(const std::string& endpointDescription);
+				std::string getEndpointName()const;
+				void setEndpointName(const std::string& endpointName);
+
+            private:
+				std::string clientToken_;
+				std::string endpointId_;
+				std::string regionId_;
+				bool dryRun_;
+				std::string endpointDescription_;
+				std::string endpointName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTATTRIBUTEREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointAttributeResult.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_PRIVATELINK_MODEL_UPDATEVPCENDPOINTATTRIBUTERESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointAttributeResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateVpcEndpointAttributeResult();
+				explicit UpdateVpcEndpointAttributeResult(const std::string &payload);
+				~UpdateVpcEndpointAttributeResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTATTRIBUTERESULT_H_

privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointConnectionAttributeRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTCONNECTIONATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTCONNECTIONATTRIBUTEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointConnectionAttributeRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateVpcEndpointConnectionAttributeRequest();
+				~UpdateVpcEndpointConnectionAttributeRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getEndpointId()const;
+				void setEndpointId(const std::string& endpointId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+				int getBandwidth()const;
+				void setBandwidth(int bandwidth);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				std::string clientToken_;
+				std::string endpointId_;
+				std::string regionId_;
+				bool dryRun_;
+				int bandwidth_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTCONNECTIONATTRIBUTEREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointConnectionAttributeResult.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_PRIVATELINK_MODEL_UPDATEVPCENDPOINTCONNECTIONATTRIBUTERESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTCONNECTIONATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointConnectionAttributeResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateVpcEndpointConnectionAttributeResult();
+				explicit UpdateVpcEndpointConnectionAttributeResult(const std::string &payload);
+				~UpdateVpcEndpointConnectionAttributeResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTCONNECTIONATTRIBUTERESULT_H_

privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceAttributeRequest.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_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointServiceAttributeRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateVpcEndpointServiceAttributeRequest();
+				~UpdateVpcEndpointServiceAttributeRequest();
+
+				bool getAutoAcceptEnabled()const;
+				void setAutoAcceptEnabled(bool autoAcceptEnabled);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				int getConnectBandwidth()const;
+				void setConnectBandwidth(int connectBandwidth);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+				std::string getServiceDescription()const;
+				void setServiceDescription(const std::string& serviceDescription);
+				std::string getServiceId()const;
+				void setServiceId(const std::string& serviceId);
+
+            private:
+				bool autoAcceptEnabled_;
+				std::string clientToken_;
+				int connectBandwidth_;
+				std::string regionId_;
+				bool dryRun_;
+				std::string serviceDescription_;
+				std::string serviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_

privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceAttributeResult.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_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTERESULT_H_
+#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/privatelink/PrivatelinkExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Privatelink
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointServiceAttributeResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateVpcEndpointServiceAttributeResult();
+				explicit UpdateVpcEndpointServiceAttributeResult(const std::string &payload);
+				~UpdateVpcEndpointServiceAttributeResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTERESULT_H_

privatelink/src/PrivatelinkClient.cc

@@ -0,0 +1,1133 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/privatelink/PrivatelinkClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Privatelink;
+using namespace AlibabaCloud::Privatelink::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "Privatelink";
+}
+
+PrivatelinkClient::PrivatelinkClient(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, "privatelink");
+}
+
+PrivatelinkClient::PrivatelinkClient(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, "privatelink");
+}
+
+PrivatelinkClient::PrivatelinkClient(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, "privatelink");
+}
+
+PrivatelinkClient::~PrivatelinkClient()
+{}
+
+PrivatelinkClient::AddUserToVpcEndpointServiceOutcome PrivatelinkClient::addUserToVpcEndpointService(const AddUserToVpcEndpointServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddUserToVpcEndpointServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddUserToVpcEndpointServiceOutcome(AddUserToVpcEndpointServiceResult(outcome.result()));
+	else
+		return AddUserToVpcEndpointServiceOutcome(outcome.error());
+}
+
+void PrivatelinkClient::addUserToVpcEndpointServiceAsync(const AddUserToVpcEndpointServiceRequest& request, const AddUserToVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addUserToVpcEndpointService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::AddUserToVpcEndpointServiceOutcomeCallable PrivatelinkClient::addUserToVpcEndpointServiceCallable(const AddUserToVpcEndpointServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddUserToVpcEndpointServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->addUserToVpcEndpointService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::AddZoneToVpcEndpointOutcome PrivatelinkClient::addZoneToVpcEndpoint(const AddZoneToVpcEndpointRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddZoneToVpcEndpointOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddZoneToVpcEndpointOutcome(AddZoneToVpcEndpointResult(outcome.result()));
+	else
+		return AddZoneToVpcEndpointOutcome(outcome.error());
+}
+
+void PrivatelinkClient::addZoneToVpcEndpointAsync(const AddZoneToVpcEndpointRequest& request, const AddZoneToVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addZoneToVpcEndpoint(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::AddZoneToVpcEndpointOutcomeCallable PrivatelinkClient::addZoneToVpcEndpointCallable(const AddZoneToVpcEndpointRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddZoneToVpcEndpointOutcome()>>(
+			[this, request]()
+			{
+			return this->addZoneToVpcEndpoint(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::AttachResourceToVpcEndpointServiceOutcome PrivatelinkClient::attachResourceToVpcEndpointService(const AttachResourceToVpcEndpointServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AttachResourceToVpcEndpointServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AttachResourceToVpcEndpointServiceOutcome(AttachResourceToVpcEndpointServiceResult(outcome.result()));
+	else
+		return AttachResourceToVpcEndpointServiceOutcome(outcome.error());
+}
+
+void PrivatelinkClient::attachResourceToVpcEndpointServiceAsync(const AttachResourceToVpcEndpointServiceRequest& request, const AttachResourceToVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, attachResourceToVpcEndpointService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::AttachResourceToVpcEndpointServiceOutcomeCallable PrivatelinkClient::attachResourceToVpcEndpointServiceCallable(const AttachResourceToVpcEndpointServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AttachResourceToVpcEndpointServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->attachResourceToVpcEndpointService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::AttachSecurityGroupToVpcEndpointOutcome PrivatelinkClient::attachSecurityGroupToVpcEndpoint(const AttachSecurityGroupToVpcEndpointRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AttachSecurityGroupToVpcEndpointOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AttachSecurityGroupToVpcEndpointOutcome(AttachSecurityGroupToVpcEndpointResult(outcome.result()));
+	else
+		return AttachSecurityGroupToVpcEndpointOutcome(outcome.error());
+}
+
+void PrivatelinkClient::attachSecurityGroupToVpcEndpointAsync(const AttachSecurityGroupToVpcEndpointRequest& request, const AttachSecurityGroupToVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, attachSecurityGroupToVpcEndpoint(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::AttachSecurityGroupToVpcEndpointOutcomeCallable PrivatelinkClient::attachSecurityGroupToVpcEndpointCallable(const AttachSecurityGroupToVpcEndpointRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AttachSecurityGroupToVpcEndpointOutcome()>>(
+			[this, request]()
+			{
+			return this->attachSecurityGroupToVpcEndpoint(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::CreateVpcEndpointOutcome PrivatelinkClient::createVpcEndpoint(const CreateVpcEndpointRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateVpcEndpointOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateVpcEndpointOutcome(CreateVpcEndpointResult(outcome.result()));
+	else
+		return CreateVpcEndpointOutcome(outcome.error());
+}
+
+void PrivatelinkClient::createVpcEndpointAsync(const CreateVpcEndpointRequest& request, const CreateVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createVpcEndpoint(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::CreateVpcEndpointOutcomeCallable PrivatelinkClient::createVpcEndpointCallable(const CreateVpcEndpointRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateVpcEndpointOutcome()>>(
+			[this, request]()
+			{
+			return this->createVpcEndpoint(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::CreateVpcEndpointServiceOutcome PrivatelinkClient::createVpcEndpointService(const CreateVpcEndpointServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateVpcEndpointServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateVpcEndpointServiceOutcome(CreateVpcEndpointServiceResult(outcome.result()));
+	else
+		return CreateVpcEndpointServiceOutcome(outcome.error());
+}
+
+void PrivatelinkClient::createVpcEndpointServiceAsync(const CreateVpcEndpointServiceRequest& request, const CreateVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createVpcEndpointService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::CreateVpcEndpointServiceOutcomeCallable PrivatelinkClient::createVpcEndpointServiceCallable(const CreateVpcEndpointServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateVpcEndpointServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->createVpcEndpointService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::DeleteVpcEndpointOutcome PrivatelinkClient::deleteVpcEndpoint(const DeleteVpcEndpointRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteVpcEndpointOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteVpcEndpointOutcome(DeleteVpcEndpointResult(outcome.result()));
+	else
+		return DeleteVpcEndpointOutcome(outcome.error());
+}
+
+void PrivatelinkClient::deleteVpcEndpointAsync(const DeleteVpcEndpointRequest& request, const DeleteVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteVpcEndpoint(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::DeleteVpcEndpointOutcomeCallable PrivatelinkClient::deleteVpcEndpointCallable(const DeleteVpcEndpointRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteVpcEndpointOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteVpcEndpoint(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::DeleteVpcEndpointServiceOutcome PrivatelinkClient::deleteVpcEndpointService(const DeleteVpcEndpointServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteVpcEndpointServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteVpcEndpointServiceOutcome(DeleteVpcEndpointServiceResult(outcome.result()));
+	else
+		return DeleteVpcEndpointServiceOutcome(outcome.error());
+}
+
+void PrivatelinkClient::deleteVpcEndpointServiceAsync(const DeleteVpcEndpointServiceRequest& request, const DeleteVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteVpcEndpointService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::DeleteVpcEndpointServiceOutcomeCallable PrivatelinkClient::deleteVpcEndpointServiceCallable(const DeleteVpcEndpointServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteVpcEndpointServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteVpcEndpointService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::DescribeRegionsOutcome PrivatelinkClient::describeRegions(const DescribeRegionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRegionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRegionsOutcome(DescribeRegionsResult(outcome.result()));
+	else
+		return DescribeRegionsOutcome(outcome.error());
+}
+
+void PrivatelinkClient::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRegions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::DescribeRegionsOutcomeCallable PrivatelinkClient::describeRegionsCallable(const DescribeRegionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRegionsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRegions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::DescribeZonesOutcome PrivatelinkClient::describeZones(const DescribeZonesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeZonesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeZonesOutcome(DescribeZonesResult(outcome.result()));
+	else
+		return DescribeZonesOutcome(outcome.error());
+}
+
+void PrivatelinkClient::describeZonesAsync(const DescribeZonesRequest& request, const DescribeZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeZones(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::DescribeZonesOutcomeCallable PrivatelinkClient::describeZonesCallable(const DescribeZonesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeZonesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeZones(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::DetachResourceFromVpcEndpointServiceOutcome PrivatelinkClient::detachResourceFromVpcEndpointService(const DetachResourceFromVpcEndpointServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetachResourceFromVpcEndpointServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetachResourceFromVpcEndpointServiceOutcome(DetachResourceFromVpcEndpointServiceResult(outcome.result()));
+	else
+		return DetachResourceFromVpcEndpointServiceOutcome(outcome.error());
+}
+
+void PrivatelinkClient::detachResourceFromVpcEndpointServiceAsync(const DetachResourceFromVpcEndpointServiceRequest& request, const DetachResourceFromVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detachResourceFromVpcEndpointService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::DetachResourceFromVpcEndpointServiceOutcomeCallable PrivatelinkClient::detachResourceFromVpcEndpointServiceCallable(const DetachResourceFromVpcEndpointServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetachResourceFromVpcEndpointServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->detachResourceFromVpcEndpointService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::DetachSecurityGroupFromVpcEndpointOutcome PrivatelinkClient::detachSecurityGroupFromVpcEndpoint(const DetachSecurityGroupFromVpcEndpointRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetachSecurityGroupFromVpcEndpointOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetachSecurityGroupFromVpcEndpointOutcome(DetachSecurityGroupFromVpcEndpointResult(outcome.result()));
+	else
+		return DetachSecurityGroupFromVpcEndpointOutcome(outcome.error());
+}
+
+void PrivatelinkClient::detachSecurityGroupFromVpcEndpointAsync(const DetachSecurityGroupFromVpcEndpointRequest& request, const DetachSecurityGroupFromVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detachSecurityGroupFromVpcEndpoint(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::DetachSecurityGroupFromVpcEndpointOutcomeCallable PrivatelinkClient::detachSecurityGroupFromVpcEndpointCallable(const DetachSecurityGroupFromVpcEndpointRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetachSecurityGroupFromVpcEndpointOutcome()>>(
+			[this, request]()
+			{
+			return this->detachSecurityGroupFromVpcEndpoint(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::DisableVpcEndpointConnectionOutcome PrivatelinkClient::disableVpcEndpointConnection(const DisableVpcEndpointConnectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DisableVpcEndpointConnectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DisableVpcEndpointConnectionOutcome(DisableVpcEndpointConnectionResult(outcome.result()));
+	else
+		return DisableVpcEndpointConnectionOutcome(outcome.error());
+}
+
+void PrivatelinkClient::disableVpcEndpointConnectionAsync(const DisableVpcEndpointConnectionRequest& request, const DisableVpcEndpointConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, disableVpcEndpointConnection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::DisableVpcEndpointConnectionOutcomeCallable PrivatelinkClient::disableVpcEndpointConnectionCallable(const DisableVpcEndpointConnectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DisableVpcEndpointConnectionOutcome()>>(
+			[this, request]()
+			{
+			return this->disableVpcEndpointConnection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::EnableVpcEndpointConnectionOutcome PrivatelinkClient::enableVpcEndpointConnection(const EnableVpcEndpointConnectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnableVpcEndpointConnectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnableVpcEndpointConnectionOutcome(EnableVpcEndpointConnectionResult(outcome.result()));
+	else
+		return EnableVpcEndpointConnectionOutcome(outcome.error());
+}
+
+void PrivatelinkClient::enableVpcEndpointConnectionAsync(const EnableVpcEndpointConnectionRequest& request, const EnableVpcEndpointConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enableVpcEndpointConnection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::EnableVpcEndpointConnectionOutcomeCallable PrivatelinkClient::enableVpcEndpointConnectionCallable(const EnableVpcEndpointConnectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnableVpcEndpointConnectionOutcome()>>(
+			[this, request]()
+			{
+			return this->enableVpcEndpointConnection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::GetVpcEndpointAttributeOutcome PrivatelinkClient::getVpcEndpointAttribute(const GetVpcEndpointAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetVpcEndpointAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetVpcEndpointAttributeOutcome(GetVpcEndpointAttributeResult(outcome.result()));
+	else
+		return GetVpcEndpointAttributeOutcome(outcome.error());
+}
+
+void PrivatelinkClient::getVpcEndpointAttributeAsync(const GetVpcEndpointAttributeRequest& request, const GetVpcEndpointAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getVpcEndpointAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::GetVpcEndpointAttributeOutcomeCallable PrivatelinkClient::getVpcEndpointAttributeCallable(const GetVpcEndpointAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetVpcEndpointAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->getVpcEndpointAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::GetVpcEndpointServiceAttributeOutcome PrivatelinkClient::getVpcEndpointServiceAttribute(const GetVpcEndpointServiceAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetVpcEndpointServiceAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetVpcEndpointServiceAttributeOutcome(GetVpcEndpointServiceAttributeResult(outcome.result()));
+	else
+		return GetVpcEndpointServiceAttributeOutcome(outcome.error());
+}
+
+void PrivatelinkClient::getVpcEndpointServiceAttributeAsync(const GetVpcEndpointServiceAttributeRequest& request, const GetVpcEndpointServiceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getVpcEndpointServiceAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::GetVpcEndpointServiceAttributeOutcomeCallable PrivatelinkClient::getVpcEndpointServiceAttributeCallable(const GetVpcEndpointServiceAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetVpcEndpointServiceAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->getVpcEndpointServiceAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::ListVpcEndpointConnectionsOutcome PrivatelinkClient::listVpcEndpointConnections(const ListVpcEndpointConnectionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListVpcEndpointConnectionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListVpcEndpointConnectionsOutcome(ListVpcEndpointConnectionsResult(outcome.result()));
+	else
+		return ListVpcEndpointConnectionsOutcome(outcome.error());
+}
+
+void PrivatelinkClient::listVpcEndpointConnectionsAsync(const ListVpcEndpointConnectionsRequest& request, const ListVpcEndpointConnectionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listVpcEndpointConnections(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::ListVpcEndpointConnectionsOutcomeCallable PrivatelinkClient::listVpcEndpointConnectionsCallable(const ListVpcEndpointConnectionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListVpcEndpointConnectionsOutcome()>>(
+			[this, request]()
+			{
+			return this->listVpcEndpointConnections(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::ListVpcEndpointSecurityGroupsOutcome PrivatelinkClient::listVpcEndpointSecurityGroups(const ListVpcEndpointSecurityGroupsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListVpcEndpointSecurityGroupsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListVpcEndpointSecurityGroupsOutcome(ListVpcEndpointSecurityGroupsResult(outcome.result()));
+	else
+		return ListVpcEndpointSecurityGroupsOutcome(outcome.error());
+}
+
+void PrivatelinkClient::listVpcEndpointSecurityGroupsAsync(const ListVpcEndpointSecurityGroupsRequest& request, const ListVpcEndpointSecurityGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listVpcEndpointSecurityGroups(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::ListVpcEndpointSecurityGroupsOutcomeCallable PrivatelinkClient::listVpcEndpointSecurityGroupsCallable(const ListVpcEndpointSecurityGroupsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListVpcEndpointSecurityGroupsOutcome()>>(
+			[this, request]()
+			{
+			return this->listVpcEndpointSecurityGroups(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::ListVpcEndpointServiceResourcesOutcome PrivatelinkClient::listVpcEndpointServiceResources(const ListVpcEndpointServiceResourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListVpcEndpointServiceResourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListVpcEndpointServiceResourcesOutcome(ListVpcEndpointServiceResourcesResult(outcome.result()));
+	else
+		return ListVpcEndpointServiceResourcesOutcome(outcome.error());
+}
+
+void PrivatelinkClient::listVpcEndpointServiceResourcesAsync(const ListVpcEndpointServiceResourcesRequest& request, const ListVpcEndpointServiceResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listVpcEndpointServiceResources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::ListVpcEndpointServiceResourcesOutcomeCallable PrivatelinkClient::listVpcEndpointServiceResourcesCallable(const ListVpcEndpointServiceResourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListVpcEndpointServiceResourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->listVpcEndpointServiceResources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::ListVpcEndpointServiceUsersOutcome PrivatelinkClient::listVpcEndpointServiceUsers(const ListVpcEndpointServiceUsersRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListVpcEndpointServiceUsersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListVpcEndpointServiceUsersOutcome(ListVpcEndpointServiceUsersResult(outcome.result()));
+	else
+		return ListVpcEndpointServiceUsersOutcome(outcome.error());
+}
+
+void PrivatelinkClient::listVpcEndpointServiceUsersAsync(const ListVpcEndpointServiceUsersRequest& request, const ListVpcEndpointServiceUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listVpcEndpointServiceUsers(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::ListVpcEndpointServiceUsersOutcomeCallable PrivatelinkClient::listVpcEndpointServiceUsersCallable(const ListVpcEndpointServiceUsersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListVpcEndpointServiceUsersOutcome()>>(
+			[this, request]()
+			{
+			return this->listVpcEndpointServiceUsers(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::ListVpcEndpointServicesOutcome PrivatelinkClient::listVpcEndpointServices(const ListVpcEndpointServicesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListVpcEndpointServicesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListVpcEndpointServicesOutcome(ListVpcEndpointServicesResult(outcome.result()));
+	else
+		return ListVpcEndpointServicesOutcome(outcome.error());
+}
+
+void PrivatelinkClient::listVpcEndpointServicesAsync(const ListVpcEndpointServicesRequest& request, const ListVpcEndpointServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listVpcEndpointServices(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::ListVpcEndpointServicesOutcomeCallable PrivatelinkClient::listVpcEndpointServicesCallable(const ListVpcEndpointServicesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListVpcEndpointServicesOutcome()>>(
+			[this, request]()
+			{
+			return this->listVpcEndpointServices(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::ListVpcEndpointServicesByEndUserOutcome PrivatelinkClient::listVpcEndpointServicesByEndUser(const ListVpcEndpointServicesByEndUserRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListVpcEndpointServicesByEndUserOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListVpcEndpointServicesByEndUserOutcome(ListVpcEndpointServicesByEndUserResult(outcome.result()));
+	else
+		return ListVpcEndpointServicesByEndUserOutcome(outcome.error());
+}
+
+void PrivatelinkClient::listVpcEndpointServicesByEndUserAsync(const ListVpcEndpointServicesByEndUserRequest& request, const ListVpcEndpointServicesByEndUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listVpcEndpointServicesByEndUser(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::ListVpcEndpointServicesByEndUserOutcomeCallable PrivatelinkClient::listVpcEndpointServicesByEndUserCallable(const ListVpcEndpointServicesByEndUserRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListVpcEndpointServicesByEndUserOutcome()>>(
+			[this, request]()
+			{
+			return this->listVpcEndpointServicesByEndUser(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::ListVpcEndpointZonesOutcome PrivatelinkClient::listVpcEndpointZones(const ListVpcEndpointZonesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListVpcEndpointZonesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListVpcEndpointZonesOutcome(ListVpcEndpointZonesResult(outcome.result()));
+	else
+		return ListVpcEndpointZonesOutcome(outcome.error());
+}
+
+void PrivatelinkClient::listVpcEndpointZonesAsync(const ListVpcEndpointZonesRequest& request, const ListVpcEndpointZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listVpcEndpointZones(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::ListVpcEndpointZonesOutcomeCallable PrivatelinkClient::listVpcEndpointZonesCallable(const ListVpcEndpointZonesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListVpcEndpointZonesOutcome()>>(
+			[this, request]()
+			{
+			return this->listVpcEndpointZones(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::ListVpcEndpointsOutcome PrivatelinkClient::listVpcEndpoints(const ListVpcEndpointsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListVpcEndpointsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListVpcEndpointsOutcome(ListVpcEndpointsResult(outcome.result()));
+	else
+		return ListVpcEndpointsOutcome(outcome.error());
+}
+
+void PrivatelinkClient::listVpcEndpointsAsync(const ListVpcEndpointsRequest& request, const ListVpcEndpointsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listVpcEndpoints(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::ListVpcEndpointsOutcomeCallable PrivatelinkClient::listVpcEndpointsCallable(const ListVpcEndpointsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListVpcEndpointsOutcome()>>(
+			[this, request]()
+			{
+			return this->listVpcEndpoints(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::OpenPrivateLinkServiceOutcome PrivatelinkClient::openPrivateLinkService(const OpenPrivateLinkServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return OpenPrivateLinkServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return OpenPrivateLinkServiceOutcome(OpenPrivateLinkServiceResult(outcome.result()));
+	else
+		return OpenPrivateLinkServiceOutcome(outcome.error());
+}
+
+void PrivatelinkClient::openPrivateLinkServiceAsync(const OpenPrivateLinkServiceRequest& request, const OpenPrivateLinkServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, openPrivateLinkService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::OpenPrivateLinkServiceOutcomeCallable PrivatelinkClient::openPrivateLinkServiceCallable(const OpenPrivateLinkServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<OpenPrivateLinkServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->openPrivateLinkService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::RemoveUserFromVpcEndpointServiceOutcome PrivatelinkClient::removeUserFromVpcEndpointService(const RemoveUserFromVpcEndpointServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RemoveUserFromVpcEndpointServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RemoveUserFromVpcEndpointServiceOutcome(RemoveUserFromVpcEndpointServiceResult(outcome.result()));
+	else
+		return RemoveUserFromVpcEndpointServiceOutcome(outcome.error());
+}
+
+void PrivatelinkClient::removeUserFromVpcEndpointServiceAsync(const RemoveUserFromVpcEndpointServiceRequest& request, const RemoveUserFromVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, removeUserFromVpcEndpointService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::RemoveUserFromVpcEndpointServiceOutcomeCallable PrivatelinkClient::removeUserFromVpcEndpointServiceCallable(const RemoveUserFromVpcEndpointServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RemoveUserFromVpcEndpointServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->removeUserFromVpcEndpointService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::RemoveZoneFromVpcEndpointOutcome PrivatelinkClient::removeZoneFromVpcEndpoint(const RemoveZoneFromVpcEndpointRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RemoveZoneFromVpcEndpointOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RemoveZoneFromVpcEndpointOutcome(RemoveZoneFromVpcEndpointResult(outcome.result()));
+	else
+		return RemoveZoneFromVpcEndpointOutcome(outcome.error());
+}
+
+void PrivatelinkClient::removeZoneFromVpcEndpointAsync(const RemoveZoneFromVpcEndpointRequest& request, const RemoveZoneFromVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, removeZoneFromVpcEndpoint(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::RemoveZoneFromVpcEndpointOutcomeCallable PrivatelinkClient::removeZoneFromVpcEndpointCallable(const RemoveZoneFromVpcEndpointRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RemoveZoneFromVpcEndpointOutcome()>>(
+			[this, request]()
+			{
+			return this->removeZoneFromVpcEndpoint(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::UpdateVpcEndpointAttributeOutcome PrivatelinkClient::updateVpcEndpointAttribute(const UpdateVpcEndpointAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateVpcEndpointAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateVpcEndpointAttributeOutcome(UpdateVpcEndpointAttributeResult(outcome.result()));
+	else
+		return UpdateVpcEndpointAttributeOutcome(outcome.error());
+}
+
+void PrivatelinkClient::updateVpcEndpointAttributeAsync(const UpdateVpcEndpointAttributeRequest& request, const UpdateVpcEndpointAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateVpcEndpointAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::UpdateVpcEndpointAttributeOutcomeCallable PrivatelinkClient::updateVpcEndpointAttributeCallable(const UpdateVpcEndpointAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateVpcEndpointAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->updateVpcEndpointAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::UpdateVpcEndpointConnectionAttributeOutcome PrivatelinkClient::updateVpcEndpointConnectionAttribute(const UpdateVpcEndpointConnectionAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateVpcEndpointConnectionAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateVpcEndpointConnectionAttributeOutcome(UpdateVpcEndpointConnectionAttributeResult(outcome.result()));
+	else
+		return UpdateVpcEndpointConnectionAttributeOutcome(outcome.error());
+}
+
+void PrivatelinkClient::updateVpcEndpointConnectionAttributeAsync(const UpdateVpcEndpointConnectionAttributeRequest& request, const UpdateVpcEndpointConnectionAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateVpcEndpointConnectionAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::UpdateVpcEndpointConnectionAttributeOutcomeCallable PrivatelinkClient::updateVpcEndpointConnectionAttributeCallable(const UpdateVpcEndpointConnectionAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateVpcEndpointConnectionAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->updateVpcEndpointConnectionAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PrivatelinkClient::UpdateVpcEndpointServiceAttributeOutcome PrivatelinkClient::updateVpcEndpointServiceAttribute(const UpdateVpcEndpointServiceAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateVpcEndpointServiceAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateVpcEndpointServiceAttributeOutcome(UpdateVpcEndpointServiceAttributeResult(outcome.result()));
+	else
+		return UpdateVpcEndpointServiceAttributeOutcome(outcome.error());
+}
+
+void PrivatelinkClient::updateVpcEndpointServiceAttributeAsync(const UpdateVpcEndpointServiceAttributeRequest& request, const UpdateVpcEndpointServiceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateVpcEndpointServiceAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PrivatelinkClient::UpdateVpcEndpointServiceAttributeOutcomeCallable PrivatelinkClient::updateVpcEndpointServiceAttributeCallable(const UpdateVpcEndpointServiceAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateVpcEndpointServiceAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->updateVpcEndpointServiceAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

privatelink/src/model/AddUserToVpcEndpointServiceRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/privatelink/model/AddUserToVpcEndpointServiceRequest.h>
+
+using AlibabaCloud::Privatelink::Model::AddUserToVpcEndpointServiceRequest;
+
+AddUserToVpcEndpointServiceRequest::AddUserToVpcEndpointServiceRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "AddUserToVpcEndpointService")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddUserToVpcEndpointServiceRequest::~AddUserToVpcEndpointServiceRequest()
+{}
+
+std::string AddUserToVpcEndpointServiceRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void AddUserToVpcEndpointServiceRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string AddUserToVpcEndpointServiceRequest::getUserId()const
+{
+	return userId_;
+}
+
+void AddUserToVpcEndpointServiceRequest::setUserId(const std::string& userId)
+{
+	userId_ = userId;
+	setParameter("UserId", userId);
+}
+
+std::string AddUserToVpcEndpointServiceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void AddUserToVpcEndpointServiceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool AddUserToVpcEndpointServiceRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void AddUserToVpcEndpointServiceRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string AddUserToVpcEndpointServiceRequest::getServiceId()const
+{
+	return serviceId_;
+}
+
+void AddUserToVpcEndpointServiceRequest::setServiceId(const std::string& serviceId)
+{
+	serviceId_ = serviceId;
+	setParameter("ServiceId", serviceId);
+}
+

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

privatelink/src/model/AddZoneToVpcEndpointRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/privatelink/model/AddZoneToVpcEndpointRequest.h>
+
+using AlibabaCloud::Privatelink::Model::AddZoneToVpcEndpointRequest;
+
+AddZoneToVpcEndpointRequest::AddZoneToVpcEndpointRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "AddZoneToVpcEndpoint")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddZoneToVpcEndpointRequest::~AddZoneToVpcEndpointRequest()
+{}
+
+std::string AddZoneToVpcEndpointRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void AddZoneToVpcEndpointRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string AddZoneToVpcEndpointRequest::getEndpointId()const
+{
+	return endpointId_;
+}
+
+void AddZoneToVpcEndpointRequest::setEndpointId(const std::string& endpointId)
+{
+	endpointId_ = endpointId;
+	setParameter("EndpointId", endpointId);
+}
+
+std::string AddZoneToVpcEndpointRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void AddZoneToVpcEndpointRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool AddZoneToVpcEndpointRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void AddZoneToVpcEndpointRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string AddZoneToVpcEndpointRequest::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+void AddZoneToVpcEndpointRequest::setVSwitchId(const std::string& vSwitchId)
+{
+	vSwitchId_ = vSwitchId;
+	setParameter("VSwitchId", vSwitchId);
+}
+
+std::string AddZoneToVpcEndpointRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void AddZoneToVpcEndpointRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setParameter("ZoneId", zoneId);
+}
+

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

privatelink/src/model/AttachResourceToVpcEndpointServiceRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/privatelink/model/AttachResourceToVpcEndpointServiceRequest.h>
+
+using AlibabaCloud::Privatelink::Model::AttachResourceToVpcEndpointServiceRequest;
+
+AttachResourceToVpcEndpointServiceRequest::AttachResourceToVpcEndpointServiceRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "AttachResourceToVpcEndpointService")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AttachResourceToVpcEndpointServiceRequest::~AttachResourceToVpcEndpointServiceRequest()
+{}
+
+std::string AttachResourceToVpcEndpointServiceRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void AttachResourceToVpcEndpointServiceRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string AttachResourceToVpcEndpointServiceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void AttachResourceToVpcEndpointServiceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string AttachResourceToVpcEndpointServiceRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void AttachResourceToVpcEndpointServiceRequest::setResourceId(const std::string& resourceId)
+{
+	resourceId_ = resourceId;
+	setParameter("ResourceId", resourceId);
+}
+
+bool AttachResourceToVpcEndpointServiceRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void AttachResourceToVpcEndpointServiceRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string AttachResourceToVpcEndpointServiceRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void AttachResourceToVpcEndpointServiceRequest::setResourceType(const std::string& resourceType)
+{
+	resourceType_ = resourceType;
+	setParameter("ResourceType", resourceType);
+}
+
+std::string AttachResourceToVpcEndpointServiceRequest::getServiceId()const
+{
+	return serviceId_;
+}
+
+void AttachResourceToVpcEndpointServiceRequest::setServiceId(const std::string& serviceId)
+{
+	serviceId_ = serviceId;
+	setParameter("ServiceId", serviceId);
+}
+

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

privatelink/src/model/AttachSecurityGroupToVpcEndpointRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/privatelink/model/AttachSecurityGroupToVpcEndpointRequest.h>
+
+using AlibabaCloud::Privatelink::Model::AttachSecurityGroupToVpcEndpointRequest;
+
+AttachSecurityGroupToVpcEndpointRequest::AttachSecurityGroupToVpcEndpointRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "AttachSecurityGroupToVpcEndpoint")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AttachSecurityGroupToVpcEndpointRequest::~AttachSecurityGroupToVpcEndpointRequest()
+{}
+
+std::string AttachSecurityGroupToVpcEndpointRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void AttachSecurityGroupToVpcEndpointRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string AttachSecurityGroupToVpcEndpointRequest::getEndpointId()const
+{
+	return endpointId_;
+}
+
+void AttachSecurityGroupToVpcEndpointRequest::setEndpointId(const std::string& endpointId)
+{
+	endpointId_ = endpointId;
+	setParameter("EndpointId", endpointId);
+}
+
+std::string AttachSecurityGroupToVpcEndpointRequest::getSecurityGroupId()const
+{
+	return securityGroupId_;
+}
+
+void AttachSecurityGroupToVpcEndpointRequest::setSecurityGroupId(const std::string& securityGroupId)
+{
+	securityGroupId_ = securityGroupId;
+	setParameter("SecurityGroupId", securityGroupId);
+}
+
+std::string AttachSecurityGroupToVpcEndpointRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void AttachSecurityGroupToVpcEndpointRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool AttachSecurityGroupToVpcEndpointRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void AttachSecurityGroupToVpcEndpointRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+

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

privatelink/src/model/CreateVpcEndpointRequest.cc

@@ -0,0 +1,146 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/privatelink/model/CreateVpcEndpointRequest.h>
+
+using AlibabaCloud::Privatelink::Model::CreateVpcEndpointRequest;
+
+CreateVpcEndpointRequest::CreateVpcEndpointRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "CreateVpcEndpoint")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateVpcEndpointRequest::~CreateVpcEndpointRequest()
+{}
+
+std::string CreateVpcEndpointRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateVpcEndpointRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::vector<std::string> CreateVpcEndpointRequest::getSecurityGroupId()const
+{
+	return securityGroupId_;
+}
+
+void CreateVpcEndpointRequest::setSecurityGroupId(const std::vector<std::string>& securityGroupId)
+{
+	securityGroupId_ = securityGroupId;
+	for(int dep1 = 0; dep1!= securityGroupId.size(); dep1++) {
+		setParameter("SecurityGroupId."+ std::to_string(dep1), securityGroupId.at(dep1));
+	}
+}
+
+std::string CreateVpcEndpointRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateVpcEndpointRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::vector<CreateVpcEndpointRequest::Zone> CreateVpcEndpointRequest::getZone()const
+{
+	return zone_;
+}
+
+void CreateVpcEndpointRequest::setZone(const std::vector<Zone>& zone)
+{
+	zone_ = zone;
+	for(int dep1 = 0; dep1!= zone.size(); dep1++) {
+		auto zoneObj = zone.at(dep1);
+		std::string zoneObjStr = "Zone." + std::to_string(dep1 + 1);
+		setParameter(zoneObjStr + ".VSwitchId", zoneObj.vSwitchId);
+		setParameter(zoneObjStr + ".ZoneId", zoneObj.zoneId);
+	}
+}
+
+std::string CreateVpcEndpointRequest::getServiceName()const
+{
+	return serviceName_;
+}
+
+void CreateVpcEndpointRequest::setServiceName(const std::string& serviceName)
+{
+	serviceName_ = serviceName;
+	setParameter("ServiceName", serviceName);
+}
+
+bool CreateVpcEndpointRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void CreateVpcEndpointRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string CreateVpcEndpointRequest::getEndpointDescription()const
+{
+	return endpointDescription_;
+}
+
+void CreateVpcEndpointRequest::setEndpointDescription(const std::string& endpointDescription)
+{
+	endpointDescription_ = endpointDescription;
+	setParameter("EndpointDescription", endpointDescription);
+}
+
+std::string CreateVpcEndpointRequest::getEndpointName()const
+{
+	return endpointName_;
+}
+
+void CreateVpcEndpointRequest::setEndpointName(const std::string& endpointName)
+{
+	endpointName_ = endpointName;
+	setParameter("EndpointName", endpointName);
+}
+
+std::string CreateVpcEndpointRequest::getVpcId()const
+{
+	return vpcId_;
+}
+
+void CreateVpcEndpointRequest::setVpcId(const std::string& vpcId)
+{
+	vpcId_ = vpcId;
+	setParameter("VpcId", vpcId);
+}
+
+std::string CreateVpcEndpointRequest::getServiceId()const
+{
+	return serviceId_;
+}
+
+void CreateVpcEndpointRequest::setServiceId(const std::string& serviceId)
+{
+	serviceId_ = serviceId;
+	setParameter("ServiceId", serviceId);
+}
+

privatelink/src/model/CreateVpcEndpointResult.cc

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/privatelink/model/CreateVpcEndpointResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Privatelink;
+using namespace AlibabaCloud::Privatelink::Model;
+
+CreateVpcEndpointResult::CreateVpcEndpointResult() :
+	ServiceResult()
+{}
+
+CreateVpcEndpointResult::CreateVpcEndpointResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateVpcEndpointResult::~CreateVpcEndpointResult()
+{}
+
+void CreateVpcEndpointResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["EndpointId"].isNull())
+		endpointId_ = value["EndpointId"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["EndpointName"].isNull())
+		endpointName_ = value["EndpointName"].asString();
+	if(!value["VpcId"].isNull())
+		vpcId_ = value["VpcId"].asString();
+	if(!value["EndpointDescription"].isNull())
+		endpointDescription_ = value["EndpointDescription"].asString();
+	if(!value["ServiceId"].isNull())
+		serviceId_ = value["ServiceId"].asString();
+	if(!value["ServiceName"].isNull())
+		serviceName_ = value["ServiceName"].asString();
+	if(!value["EndpointBusinessStatus"].isNull())
+		endpointBusinessStatus_ = value["EndpointBusinessStatus"].asString();
+	if(!value["EndpointStatus"].isNull())
+		endpointStatus_ = value["EndpointStatus"].asString();
+	if(!value["ConnectionStatus"].isNull())
+		connectionStatus_ = value["ConnectionStatus"].asString();
+	if(!value["EndpointDomain"].isNull())
+		endpointDomain_ = value["EndpointDomain"].asString();
+	if(!value["Bandwidth"].isNull())
+		bandwidth_ = std::stol(value["Bandwidth"].asString());
+
+}
+
+std::string CreateVpcEndpointResult::getEndpointStatus()const
+{
+	return endpointStatus_;
+}
+
+std::string CreateVpcEndpointResult::getEndpointName()const
+{
+	return endpointName_;
+}
+
+std::string CreateVpcEndpointResult::getVpcId()const
+{
+	return vpcId_;
+}
+
+std::string CreateVpcEndpointResult::getEndpointDomain()const
+{
+	return endpointDomain_;
+}
+
+std::string CreateVpcEndpointResult::getServiceName()const
+{
+	return serviceName_;
+}
+
+std::string CreateVpcEndpointResult::getEndpointId()const
+{
+	return endpointId_;
+}
+
+std::string CreateVpcEndpointResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+long CreateVpcEndpointResult::getBandwidth()const
+{
+	return bandwidth_;
+}
+
+std::string CreateVpcEndpointResult::getEndpointBusinessStatus()const
+{
+	return endpointBusinessStatus_;
+}
+
+std::string CreateVpcEndpointResult::getEndpointDescription()const
+{
+	return endpointDescription_;
+}
+
+std::string CreateVpcEndpointResult::getConnectionStatus()const
+{
+	return connectionStatus_;
+}
+
+std::string CreateVpcEndpointResult::getServiceId()const
+{
+	return serviceId_;
+}
+

privatelink/src/model/CreateVpcEndpointServiceRequest.cc

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/privatelink/model/CreateVpcEndpointServiceRequest.h>
+
+using AlibabaCloud::Privatelink::Model::CreateVpcEndpointServiceRequest;
+
+CreateVpcEndpointServiceRequest::CreateVpcEndpointServiceRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "CreateVpcEndpointService")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateVpcEndpointServiceRequest::~CreateVpcEndpointServiceRequest()
+{}
+
+bool CreateVpcEndpointServiceRequest::getAutoAcceptEnabled()const
+{
+	return autoAcceptEnabled_;
+}
+
+void CreateVpcEndpointServiceRequest::setAutoAcceptEnabled(bool autoAcceptEnabled)
+{
+	autoAcceptEnabled_ = autoAcceptEnabled;
+	setParameter("AutoAcceptEnabled", autoAcceptEnabled ? "true" : "false");
+}
+
+std::string CreateVpcEndpointServiceRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateVpcEndpointServiceRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string CreateVpcEndpointServiceRequest::getPayer()const
+{
+	return payer_;
+}
+
+void CreateVpcEndpointServiceRequest::setPayer(const std::string& payer)
+{
+	payer_ = payer;
+	setParameter("Payer", payer);
+}
+
+std::string CreateVpcEndpointServiceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateVpcEndpointServiceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool CreateVpcEndpointServiceRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void CreateVpcEndpointServiceRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::vector<CreateVpcEndpointServiceRequest::Resource> CreateVpcEndpointServiceRequest::getResource()const
+{
+	return resource_;
+}
+
+void CreateVpcEndpointServiceRequest::setResource(const std::vector<Resource>& resource)
+{
+	resource_ = resource;
+	for(int dep1 = 0; dep1!= resource.size(); dep1++) {
+		auto resourceObj = resource.at(dep1);
+		std::string resourceObjStr = "Resource." + std::to_string(dep1 + 1);
+		setParameter(resourceObjStr + ".ResourceId", resourceObj.resourceId);
+		setParameter(resourceObjStr + ".ResourceType", resourceObj.resourceType);
+	}
+}
+
+std::string CreateVpcEndpointServiceRequest::getServiceDescription()const
+{
+	return serviceDescription_;
+}
+
+void CreateVpcEndpointServiceRequest::setServiceDescription(const std::string& serviceDescription)
+{
+	serviceDescription_ = serviceDescription;
+	setParameter("ServiceDescription", serviceDescription);
+}
+

privatelink/src/model/CreateVpcEndpointServiceResult.cc

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/privatelink/model/CreateVpcEndpointServiceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Privatelink;
+using namespace AlibabaCloud::Privatelink::Model;
+
+CreateVpcEndpointServiceResult::CreateVpcEndpointServiceResult() :
+	ServiceResult()
+{}
+
+CreateVpcEndpointServiceResult::CreateVpcEndpointServiceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateVpcEndpointServiceResult::~CreateVpcEndpointServiceResult()
+{}
+
+void CreateVpcEndpointServiceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AutoAcceptEnabled"].isNull())
+		autoAcceptEnabled_ = value["AutoAcceptEnabled"].asString() == "true";
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["ServiceBusinessStatus"].isNull())
+		serviceBusinessStatus_ = value["ServiceBusinessStatus"].asString();
+	if(!value["ServiceDescription"].isNull())
+		serviceDescription_ = value["ServiceDescription"].asString();
+	if(!value["ServiceDomain"].isNull())
+		serviceDomain_ = value["ServiceDomain"].asString();
+	if(!value["ServiceId"].isNull())
+		serviceId_ = value["ServiceId"].asString();
+	if(!value["ServiceName"].isNull())
+		serviceName_ = value["ServiceName"].asString();
+	if(!value["ServiceStatus"].isNull())
+		serviceStatus_ = value["ServiceStatus"].asString();
+
+}
+
+std::string CreateVpcEndpointServiceResult::getServiceBusinessStatus()const
+{
+	return serviceBusinessStatus_;
+}
+
+std::string CreateVpcEndpointServiceResult::getServiceName()const
+{
+	return serviceName_;
+}
+
+std::string CreateVpcEndpointServiceResult::getServiceDescription()const
+{
+	return serviceDescription_;
+}
+
+std::string CreateVpcEndpointServiceResult::getServiceStatus()const
+{
+	return serviceStatus_;
+}
+
+std::string CreateVpcEndpointServiceResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+std::string CreateVpcEndpointServiceResult::getServiceDomain()const
+{
+	return serviceDomain_;
+}
+
+bool CreateVpcEndpointServiceResult::getAutoAcceptEnabled()const
+{
+	return autoAcceptEnabled_;
+}
+
+std::string CreateVpcEndpointServiceResult::getServiceId()const
+{
+	return serviceId_;
+}
+

privatelink/src/model/DeleteVpcEndpointRequest.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/privatelink/model/DeleteVpcEndpointRequest.h>
+
+using AlibabaCloud::Privatelink::Model::DeleteVpcEndpointRequest;
+
+DeleteVpcEndpointRequest::DeleteVpcEndpointRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "DeleteVpcEndpoint")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteVpcEndpointRequest::~DeleteVpcEndpointRequest()
+{}
+
+std::string DeleteVpcEndpointRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void DeleteVpcEndpointRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string DeleteVpcEndpointRequest::getEndpointId()const
+{
+	return endpointId_;
+}
+
+void DeleteVpcEndpointRequest::setEndpointId(const std::string& endpointId)
+{
+	endpointId_ = endpointId;
+	setParameter("EndpointId", endpointId);
+}
+
+std::string DeleteVpcEndpointRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteVpcEndpointRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool DeleteVpcEndpointRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void DeleteVpcEndpointRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+

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

privatelink/src/model/DeleteVpcEndpointServiceRequest.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/privatelink/model/DeleteVpcEndpointServiceRequest.h>
+
+using AlibabaCloud::Privatelink::Model::DeleteVpcEndpointServiceRequest;
+
+DeleteVpcEndpointServiceRequest::DeleteVpcEndpointServiceRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "DeleteVpcEndpointService")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteVpcEndpointServiceRequest::~DeleteVpcEndpointServiceRequest()
+{}
+
+std::string DeleteVpcEndpointServiceRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void DeleteVpcEndpointServiceRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string DeleteVpcEndpointServiceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteVpcEndpointServiceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool DeleteVpcEndpointServiceRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void DeleteVpcEndpointServiceRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string DeleteVpcEndpointServiceRequest::getServiceId()const
+{
+	return serviceId_;
+}
+
+void DeleteVpcEndpointServiceRequest::setServiceId(const std::string& serviceId)
+{
+	serviceId_ = serviceId;
+	setParameter("ServiceId", serviceId);
+}
+

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

privatelink/src/model/DescribeRegionsRequest.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/privatelink/model/DescribeRegionsRequest.h>
+
+using AlibabaCloud::Privatelink::Model::DescribeRegionsRequest;
+
+DescribeRegionsRequest::DescribeRegionsRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "DescribeRegions")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeRegionsRequest::~DescribeRegionsRequest()
+{}
+
+std::string DescribeRegionsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeRegionsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+

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

privatelink/src/model/DescribeZonesRequest.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/privatelink/model/DescribeZonesRequest.h>
+
+using AlibabaCloud::Privatelink::Model::DescribeZonesRequest;
+
+DescribeZonesRequest::DescribeZonesRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "DescribeZones")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeZonesRequest::~DescribeZonesRequest()
+{}
+
+std::string DescribeZonesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeZonesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+

privatelink/src/model/DescribeZonesResult.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/privatelink/model/DescribeZonesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Privatelink;
+using namespace AlibabaCloud::Privatelink::Model;
+
+DescribeZonesResult::DescribeZonesResult() :
+	ServiceResult()
+{}
+
+DescribeZonesResult::DescribeZonesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeZonesResult::~DescribeZonesResult()
+{}
+
+void DescribeZonesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allZonesNode = value["Zones"]["Zone"];
+	for (auto valueZonesZone : allZonesNode)
+	{
+		Zone zonesObject;
+		if(!valueZonesZone["ZoneId"].isNull())
+			zonesObject.zoneId = valueZonesZone["ZoneId"].asString();
+		if(!valueZonesZone["LocalName"].isNull())
+			zonesObject.localName = valueZonesZone["LocalName"].asString();
+		zones_.push_back(zonesObject);
+	}
+
+}
+
+std::vector<DescribeZonesResult::Zone> DescribeZonesResult::getZones()const
+{
+	return zones_;
+}
+

privatelink/src/model/DetachResourceFromVpcEndpointServiceRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/privatelink/model/DetachResourceFromVpcEndpointServiceRequest.h>
+
+using AlibabaCloud::Privatelink::Model::DetachResourceFromVpcEndpointServiceRequest;
+
+DetachResourceFromVpcEndpointServiceRequest::DetachResourceFromVpcEndpointServiceRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "DetachResourceFromVpcEndpointService")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DetachResourceFromVpcEndpointServiceRequest::~DetachResourceFromVpcEndpointServiceRequest()
+{}
+
+std::string DetachResourceFromVpcEndpointServiceRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void DetachResourceFromVpcEndpointServiceRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string DetachResourceFromVpcEndpointServiceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DetachResourceFromVpcEndpointServiceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DetachResourceFromVpcEndpointServiceRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void DetachResourceFromVpcEndpointServiceRequest::setResourceId(const std::string& resourceId)
+{
+	resourceId_ = resourceId;
+	setParameter("ResourceId", resourceId);
+}
+
+bool DetachResourceFromVpcEndpointServiceRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void DetachResourceFromVpcEndpointServiceRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string DetachResourceFromVpcEndpointServiceRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void DetachResourceFromVpcEndpointServiceRequest::setResourceType(const std::string& resourceType)
+{
+	resourceType_ = resourceType;
+	setParameter("ResourceType", resourceType);
+}
+
+std::string DetachResourceFromVpcEndpointServiceRequest::getServiceId()const
+{
+	return serviceId_;
+}
+
+void DetachResourceFromVpcEndpointServiceRequest::setServiceId(const std::string& serviceId)
+{
+	serviceId_ = serviceId;
+	setParameter("ServiceId", serviceId);
+}
+

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

privatelink/src/model/DetachSecurityGroupFromVpcEndpointRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/privatelink/model/DetachSecurityGroupFromVpcEndpointRequest.h>
+
+using AlibabaCloud::Privatelink::Model::DetachSecurityGroupFromVpcEndpointRequest;
+
+DetachSecurityGroupFromVpcEndpointRequest::DetachSecurityGroupFromVpcEndpointRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "DetachSecurityGroupFromVpcEndpoint")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DetachSecurityGroupFromVpcEndpointRequest::~DetachSecurityGroupFromVpcEndpointRequest()
+{}
+
+std::string DetachSecurityGroupFromVpcEndpointRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void DetachSecurityGroupFromVpcEndpointRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string DetachSecurityGroupFromVpcEndpointRequest::getEndpointId()const
+{
+	return endpointId_;
+}
+
+void DetachSecurityGroupFromVpcEndpointRequest::setEndpointId(const std::string& endpointId)
+{
+	endpointId_ = endpointId;
+	setParameter("EndpointId", endpointId);
+}
+
+std::string DetachSecurityGroupFromVpcEndpointRequest::getSecurityGroupId()const
+{
+	return securityGroupId_;
+}
+
+void DetachSecurityGroupFromVpcEndpointRequest::setSecurityGroupId(const std::string& securityGroupId)
+{
+	securityGroupId_ = securityGroupId;
+	setParameter("SecurityGroupId", securityGroupId);
+}
+
+std::string DetachSecurityGroupFromVpcEndpointRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DetachSecurityGroupFromVpcEndpointRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool DetachSecurityGroupFromVpcEndpointRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void DetachSecurityGroupFromVpcEndpointRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+

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

privatelink/src/model/DisableVpcEndpointConnectionRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/privatelink/model/DisableVpcEndpointConnectionRequest.h>
+
+using AlibabaCloud::Privatelink::Model::DisableVpcEndpointConnectionRequest;
+
+DisableVpcEndpointConnectionRequest::DisableVpcEndpointConnectionRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "DisableVpcEndpointConnection")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DisableVpcEndpointConnectionRequest::~DisableVpcEndpointConnectionRequest()
+{}
+
+std::string DisableVpcEndpointConnectionRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void DisableVpcEndpointConnectionRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string DisableVpcEndpointConnectionRequest::getEndpointId()const
+{
+	return endpointId_;
+}
+
+void DisableVpcEndpointConnectionRequest::setEndpointId(const std::string& endpointId)
+{
+	endpointId_ = endpointId;
+	setParameter("EndpointId", endpointId);
+}
+
+std::string DisableVpcEndpointConnectionRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DisableVpcEndpointConnectionRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool DisableVpcEndpointConnectionRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void DisableVpcEndpointConnectionRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string DisableVpcEndpointConnectionRequest::getServiceId()const
+{
+	return serviceId_;
+}
+
+void DisableVpcEndpointConnectionRequest::setServiceId(const std::string& serviceId)
+{
+	serviceId_ = serviceId;
+	setParameter("ServiceId", serviceId);
+}
+

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

privatelink/src/model/EnableVpcEndpointConnectionRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/privatelink/model/EnableVpcEndpointConnectionRequest.h>
+
+using AlibabaCloud::Privatelink::Model::EnableVpcEndpointConnectionRequest;
+
+EnableVpcEndpointConnectionRequest::EnableVpcEndpointConnectionRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "EnableVpcEndpointConnection")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+EnableVpcEndpointConnectionRequest::~EnableVpcEndpointConnectionRequest()
+{}
+
+std::string EnableVpcEndpointConnectionRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void EnableVpcEndpointConnectionRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string EnableVpcEndpointConnectionRequest::getEndpointId()const
+{
+	return endpointId_;
+}
+
+void EnableVpcEndpointConnectionRequest::setEndpointId(const std::string& endpointId)
+{
+	endpointId_ = endpointId;
+	setParameter("EndpointId", endpointId);
+}
+
+std::string EnableVpcEndpointConnectionRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void EnableVpcEndpointConnectionRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool EnableVpcEndpointConnectionRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void EnableVpcEndpointConnectionRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+int EnableVpcEndpointConnectionRequest::getBandwidth()const
+{
+	return bandwidth_;
+}
+
+void EnableVpcEndpointConnectionRequest::setBandwidth(int bandwidth)
+{
+	bandwidth_ = bandwidth;
+	setParameter("Bandwidth", std::to_string(bandwidth));
+}
+
+std::string EnableVpcEndpointConnectionRequest::getServiceId()const
+{
+	return serviceId_;
+}
+
+void EnableVpcEndpointConnectionRequest::setServiceId(const std::string& serviceId)
+{
+	serviceId_ = serviceId;
+	setParameter("ServiceId", serviceId);
+}
+

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

privatelink/src/model/GetVpcEndpointAttributeRequest.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/privatelink/model/GetVpcEndpointAttributeRequest.h>
+
+using AlibabaCloud::Privatelink::Model::GetVpcEndpointAttributeRequest;
+
+GetVpcEndpointAttributeRequest::GetVpcEndpointAttributeRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "GetVpcEndpointAttribute")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetVpcEndpointAttributeRequest::~GetVpcEndpointAttributeRequest()
+{}
+
+std::string GetVpcEndpointAttributeRequest::getEndpointId()const
+{
+	return endpointId_;
+}
+
+void GetVpcEndpointAttributeRequest::setEndpointId(const std::string& endpointId)
+{
+	endpointId_ = endpointId;
+	setParameter("EndpointId", endpointId);
+}
+
+std::string GetVpcEndpointAttributeRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetVpcEndpointAttributeRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+

privatelink/src/model/GetVpcEndpointAttributeResult.cc

@@ -0,0 +1,149 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/privatelink/model/GetVpcEndpointAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Privatelink;
+using namespace AlibabaCloud::Privatelink::Model;
+
+GetVpcEndpointAttributeResult::GetVpcEndpointAttributeResult() :
+	ServiceResult()
+{}
+
+GetVpcEndpointAttributeResult::GetVpcEndpointAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetVpcEndpointAttributeResult::~GetVpcEndpointAttributeResult()
+{}
+
+void GetVpcEndpointAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Bandwidth"].isNull())
+		bandwidth_ = std::stoi(value["Bandwidth"].asString());
+	if(!value["ConnectionStatus"].isNull())
+		connectionStatus_ = value["ConnectionStatus"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["EndpointBusinessStatus"].isNull())
+		endpointBusinessStatus_ = value["EndpointBusinessStatus"].asString();
+	if(!value["EndpointDescription"].isNull())
+		endpointDescription_ = value["EndpointDescription"].asString();
+	if(!value["EndpointDomain"].isNull())
+		endpointDomain_ = value["EndpointDomain"].asString();
+	if(!value["EndpointId"].isNull())
+		endpointId_ = value["EndpointId"].asString();
+	if(!value["EndpointName"].isNull())
+		endpointName_ = value["EndpointName"].asString();
+	if(!value["EndpointStatus"].isNull())
+		endpointStatus_ = value["EndpointStatus"].asString();
+	if(!value["ServiceId"].isNull())
+		serviceId_ = value["ServiceId"].asString();
+	if(!value["ServiceName"].isNull())
+		serviceName_ = value["ServiceName"].asString();
+	if(!value["VpcId"].isNull())
+		vpcId_ = value["VpcId"].asString();
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+	if(!value["Payer"].isNull())
+		payer_ = value["Payer"].asString();
+	if(!value["ResourceOwner"].isNull())
+		resourceOwner_ = value["ResourceOwner"].asString() == "true";
+
+}
+
+std::string GetVpcEndpointAttributeResult::getPayer()const
+{
+	return payer_;
+}
+
+std::string GetVpcEndpointAttributeResult::getEndpointDomain()const
+{
+	return endpointDomain_;
+}
+
+std::string GetVpcEndpointAttributeResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+bool GetVpcEndpointAttributeResult::getResourceOwner()const
+{
+	return resourceOwner_;
+}
+
+std::string GetVpcEndpointAttributeResult::getEndpointBusinessStatus()const
+{
+	return endpointBusinessStatus_;
+}
+
+std::string GetVpcEndpointAttributeResult::getEndpointDescription()const
+{
+	return endpointDescription_;
+}
+
+std::string GetVpcEndpointAttributeResult::getServiceId()const
+{
+	return serviceId_;
+}
+
+std::string GetVpcEndpointAttributeResult::getEndpointStatus()const
+{
+	return endpointStatus_;
+}
+
+std::string GetVpcEndpointAttributeResult::getEndpointName()const
+{
+	return endpointName_;
+}
+
+std::string GetVpcEndpointAttributeResult::getVpcId()const
+{
+	return vpcId_;
+}
+
+std::string GetVpcEndpointAttributeResult::getServiceName()const
+{
+	return serviceName_;
+}
+
+int GetVpcEndpointAttributeResult::getBandwidth()const
+{
+	return bandwidth_;
+}
+
+std::string GetVpcEndpointAttributeResult::getEndpointId()const
+{
+	return endpointId_;
+}
+
+std::string GetVpcEndpointAttributeResult::getRegionId()const
+{
+	return regionId_;
+}
+
+std::string GetVpcEndpointAttributeResult::getConnectionStatus()const
+{
+	return connectionStatus_;
+}
+

privatelink/src/model/GetVpcEndpointServiceAttributeRequest.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/privatelink/model/GetVpcEndpointServiceAttributeRequest.h>
+
+using AlibabaCloud::Privatelink::Model::GetVpcEndpointServiceAttributeRequest;
+
+GetVpcEndpointServiceAttributeRequest::GetVpcEndpointServiceAttributeRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "GetVpcEndpointServiceAttribute")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetVpcEndpointServiceAttributeRequest::~GetVpcEndpointServiceAttributeRequest()
+{}
+
+std::string GetVpcEndpointServiceAttributeRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetVpcEndpointServiceAttributeRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string GetVpcEndpointServiceAttributeRequest::getServiceId()const
+{
+	return serviceId_;
+}
+
+void GetVpcEndpointServiceAttributeRequest::setServiceId(const std::string& serviceId)
+{
+	serviceId_ = serviceId;
+	setParameter("ServiceId", serviceId);
+}
+

privatelink/src/model/GetVpcEndpointServiceAttributeResult.cc

@@ -0,0 +1,143 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/privatelink/model/GetVpcEndpointServiceAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Privatelink;
+using namespace AlibabaCloud::Privatelink::Model;
+
+GetVpcEndpointServiceAttributeResult::GetVpcEndpointServiceAttributeResult() :
+	ServiceResult()
+{}
+
+GetVpcEndpointServiceAttributeResult::GetVpcEndpointServiceAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetVpcEndpointServiceAttributeResult::~GetVpcEndpointServiceAttributeResult()
+{}
+
+void GetVpcEndpointServiceAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allZones = value["Zones"]["Zone"];
+	for (const auto &item : allZones)
+		zones_.push_back(item.asString());
+	if(!value["ServiceId"].isNull())
+		serviceId_ = value["ServiceId"].asString();
+	if(!value["ServiceName"].isNull())
+		serviceName_ = value["ServiceName"].asString();
+	if(!value["ServiceDomain"].isNull())
+		serviceDomain_ = value["ServiceDomain"].asString();
+	if(!value["ServiceDescription"].isNull())
+		serviceDescription_ = value["ServiceDescription"].asString();
+	if(!value["ServiceBusinessStatus"].isNull())
+		serviceBusinessStatus_ = value["ServiceBusinessStatus"].asString();
+	if(!value["ServiceStatus"].isNull())
+		serviceStatus_ = value["ServiceStatus"].asString();
+	if(!value["AutoAcceptEnabled"].isNull())
+		autoAcceptEnabled_ = value["AutoAcceptEnabled"].asString() == "true";
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["MaxBandwidth"].isNull())
+		maxBandwidth_ = std::stoi(value["MaxBandwidth"].asString());
+	if(!value["MinBandwidth"].isNull())
+		minBandwidth_ = std::stoi(value["MinBandwidth"].asString());
+	if(!value["ConnectBandwidth"].isNull())
+		connectBandwidth_ = std::stoi(value["ConnectBandwidth"].asString());
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+	if(!value["Payer"].isNull())
+		payer_ = value["Payer"].asString();
+
+}
+
+std::string GetVpcEndpointServiceAttributeResult::getPayer()const
+{
+	return payer_;
+}
+
+std::string GetVpcEndpointServiceAttributeResult::getServiceDescription()const
+{
+	return serviceDescription_;
+}
+
+std::string GetVpcEndpointServiceAttributeResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+int GetVpcEndpointServiceAttributeResult::getMaxBandwidth()const
+{
+	return maxBandwidth_;
+}
+
+std::string GetVpcEndpointServiceAttributeResult::getServiceDomain()const
+{
+	return serviceDomain_;
+}
+
+int GetVpcEndpointServiceAttributeResult::getMinBandwidth()const
+{
+	return minBandwidth_;
+}
+
+std::vector<std::string> GetVpcEndpointServiceAttributeResult::getZones()const
+{
+	return zones_;
+}
+
+std::string GetVpcEndpointServiceAttributeResult::getServiceId()const
+{
+	return serviceId_;
+}
+
+bool GetVpcEndpointServiceAttributeResult::getAutoAcceptEnabled()const
+{
+	return autoAcceptEnabled_;
+}
+
+std::string GetVpcEndpointServiceAttributeResult::getServiceBusinessStatus()const
+{
+	return serviceBusinessStatus_;
+}
+
+std::string GetVpcEndpointServiceAttributeResult::getServiceName()const
+{
+	return serviceName_;
+}
+
+std::string GetVpcEndpointServiceAttributeResult::getServiceStatus()const
+{
+	return serviceStatus_;
+}
+
+int GetVpcEndpointServiceAttributeResult::getConnectBandwidth()const
+{
+	return connectBandwidth_;
+}
+
+std::string GetVpcEndpointServiceAttributeResult::getRegionId()const
+{
+	return regionId_;
+}
+

privatelink/src/model/ListVpcEndpointConnectionsRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/privatelink/model/ListVpcEndpointConnectionsRequest.h>
+
+using AlibabaCloud::Privatelink::Model::ListVpcEndpointConnectionsRequest;
+
+ListVpcEndpointConnectionsRequest::ListVpcEndpointConnectionsRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointConnections")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListVpcEndpointConnectionsRequest::~ListVpcEndpointConnectionsRequest()
+{}
+
+std::string ListVpcEndpointConnectionsRequest::getEndpointId()const
+{
+	return endpointId_;
+}
+
+void ListVpcEndpointConnectionsRequest::setEndpointId(const std::string& endpointId)
+{
+	endpointId_ = endpointId;
+	setParameter("EndpointId", endpointId);
+}
+
+long ListVpcEndpointConnectionsRequest::getEndpointOwnerId()const
+{
+	return endpointOwnerId_;
+}
+
+void ListVpcEndpointConnectionsRequest::setEndpointOwnerId(long endpointOwnerId)
+{
+	endpointOwnerId_ = endpointOwnerId;
+	setParameter("EndpointOwnerId", std::to_string(endpointOwnerId));
+}
+
+std::string ListVpcEndpointConnectionsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ListVpcEndpointConnectionsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string ListVpcEndpointConnectionsRequest::getNextToken()const
+{
+	return nextToken_;
+}
+
+void ListVpcEndpointConnectionsRequest::setNextToken(const std::string& nextToken)
+{
+	nextToken_ = nextToken;
+	setParameter("NextToken", nextToken);
+}
+
+std::string ListVpcEndpointConnectionsRequest::getConnectionStatus()const
+{
+	return connectionStatus_;
+}
+
+void ListVpcEndpointConnectionsRequest::setConnectionStatus(const std::string& connectionStatus)
+{
+	connectionStatus_ = connectionStatus;
+	setParameter("ConnectionStatus", connectionStatus);
+}
+
+int ListVpcEndpointConnectionsRequest::getMaxResults()const
+{
+	return maxResults_;
+}
+
+void ListVpcEndpointConnectionsRequest::setMaxResults(int maxResults)
+{
+	maxResults_ = maxResults;
+	setParameter("MaxResults", std::to_string(maxResults));
+}
+
+std::string ListVpcEndpointConnectionsRequest::getServiceId()const
+{
+	return serviceId_;
+}
+
+void ListVpcEndpointConnectionsRequest::setServiceId(const std::string& serviceId)
+{
+	serviceId_ = serviceId;
+	setParameter("ServiceId", serviceId);
+}
+

privatelink/src/model/ListVpcEndpointConnectionsResult.cc

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/privatelink/model/ListVpcEndpointConnectionsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Privatelink;
+using namespace AlibabaCloud::Privatelink::Model;
+
+ListVpcEndpointConnectionsResult::ListVpcEndpointConnectionsResult() :
+	ServiceResult()
+{}
+
+ListVpcEndpointConnectionsResult::ListVpcEndpointConnectionsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListVpcEndpointConnectionsResult::~ListVpcEndpointConnectionsResult()
+{}
+
+void ListVpcEndpointConnectionsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allConnectionsNode = value["Connections"]["Connection"];
+	for (auto valueConnectionsConnection : allConnectionsNode)
+	{
+		Connection connectionsObject;
+		if(!valueConnectionsConnection["ServiceId"].isNull())
+			connectionsObject.serviceId = valueConnectionsConnection["ServiceId"].asString();
+		if(!valueConnectionsConnection["EndpointId"].isNull())
+			connectionsObject.endpointId = valueConnectionsConnection["EndpointId"].asString();
+		if(!valueConnectionsConnection["EndpointOwnerId"].isNull())
+			connectionsObject.endpointOwnerId = std::stol(valueConnectionsConnection["EndpointOwnerId"].asString());
+		if(!valueConnectionsConnection["ConnectionStatus"].isNull())
+			connectionsObject.connectionStatus = valueConnectionsConnection["ConnectionStatus"].asString();
+		if(!valueConnectionsConnection["EndpointVpcId"].isNull())
+			connectionsObject.endpointVpcId = valueConnectionsConnection["EndpointVpcId"].asString();
+		if(!valueConnectionsConnection["Bandwidth"].isNull())
+			connectionsObject.bandwidth = std::stoi(valueConnectionsConnection["Bandwidth"].asString());
+		if(!valueConnectionsConnection["ModifiedTime"].isNull())
+			connectionsObject.modifiedTime = valueConnectionsConnection["ModifiedTime"].asString();
+		if(!valueConnectionsConnection["ResourceOwner"].isNull())
+			connectionsObject.resourceOwner = valueConnectionsConnection["ResourceOwner"].asString() == "true";
+		auto allZonesNode = valueConnectionsConnection["Zones"]["Zone"];
+		for (auto valueConnectionsConnectionZonesZone : allZonesNode)
+		{
+			Connection::Zone zonesObject;
+			if(!valueConnectionsConnectionZonesZone["ZoneId"].isNull())
+				zonesObject.zoneId = valueConnectionsConnectionZonesZone["ZoneId"].asString();
+			if(!valueConnectionsConnectionZonesZone["EniId"].isNull())
+				zonesObject.eniId = valueConnectionsConnectionZonesZone["EniId"].asString();
+			if(!valueConnectionsConnectionZonesZone["ZoneDomain"].isNull())
+				zonesObject.zoneDomain = valueConnectionsConnectionZonesZone["ZoneDomain"].asString();
+			if(!valueConnectionsConnectionZonesZone["VSwitchId"].isNull())
+				zonesObject.vSwitchId = valueConnectionsConnectionZonesZone["VSwitchId"].asString();
+			if(!valueConnectionsConnectionZonesZone["ResourceId"].isNull())
+				zonesObject.resourceId = valueConnectionsConnectionZonesZone["ResourceId"].asString();
+			connectionsObject.zones.push_back(zonesObject);
+		}
+		connections_.push_back(connectionsObject);
+	}
+	if(!value["MaxResults"].isNull())
+		maxResults_ = value["MaxResults"].asString();
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+
+}
+
+std::vector<ListVpcEndpointConnectionsResult::Connection> ListVpcEndpointConnectionsResult::getConnections()const
+{
+	return connections_;
+}
+
+std::string ListVpcEndpointConnectionsResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::string ListVpcEndpointConnectionsResult::getMaxResults()const
+{
+	return maxResults_;
+}
+

privatelink/src/model/ListVpcEndpointSecurityGroupsRequest.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/privatelink/model/ListVpcEndpointSecurityGroupsRequest.h>
+
+using AlibabaCloud::Privatelink::Model::ListVpcEndpointSecurityGroupsRequest;
+
+ListVpcEndpointSecurityGroupsRequest::ListVpcEndpointSecurityGroupsRequest() :
+	RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointSecurityGroups")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListVpcEndpointSecurityGroupsRequest::~ListVpcEndpointSecurityGroupsRequest()
+{}
+
+std::string ListVpcEndpointSecurityGroupsRequest::getEndpointId()const
+{
+	return endpointId_;
+}
+
+void ListVpcEndpointSecurityGroupsRequest::setEndpointId(const std::string& endpointId)
+{
+	endpointId_ = endpointId;
+	setParameter("EndpointId", endpointId);
+}
+
+std::string ListVpcEndpointSecurityGroupsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ListVpcEndpointSecurityGroupsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string ListVpcEndpointSecurityGroupsRequest::getNextToken()const
+{
+	return nextToken_;
+}
+
+void ListVpcEndpointSecurityGroupsRequest::setNextToken(const std::string& nextToken)
+{
+	nextToken_ = nextToken;
+	setParameter("NextToken", nextToken);
+}
+
+int ListVpcEndpointSecurityGroupsRequest::getMaxResults()const
+{
+	return maxResults_;
+}
+
+void ListVpcEndpointSecurityGroupsRequest::setMaxResults(int maxResults)
+{
+	maxResults_ = maxResults;
+	setParameter("MaxResults", std::to_string(maxResults));
+}
+