Generated 2022-04-30 for Nlb.

VERSION

@@ -1 +1 @@
-1.36.1771
+1.36.1772

nlb/CMakeLists.txt

@@ -0,0 +1,270 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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(nlb_public_header 
+	include/alibabacloud/nlb/NlbClient.h
+	include/alibabacloud/nlb/NlbExport.h )
+
+set(nlb_public_header_model 
+	include/alibabacloud/nlb/model/AddServersToServerGroupRequest.h
+	include/alibabacloud/nlb/model/AddServersToServerGroupResult.h
+	include/alibabacloud/nlb/model/AssociateAdditionalCertificatesWithListenerRequest.h
+	include/alibabacloud/nlb/model/AssociateAdditionalCertificatesWithListenerResult.h
+	include/alibabacloud/nlb/model/AttachCommonBandwidthPackageToLoadBalancerRequest.h
+	include/alibabacloud/nlb/model/AttachCommonBandwidthPackageToLoadBalancerResult.h
+	include/alibabacloud/nlb/model/CancelShiftLoadBalancerZonesRequest.h
+	include/alibabacloud/nlb/model/CancelShiftLoadBalancerZonesResult.h
+	include/alibabacloud/nlb/model/CreateListenerRequest.h
+	include/alibabacloud/nlb/model/CreateListenerResult.h
+	include/alibabacloud/nlb/model/CreateLoadBalancerRequest.h
+	include/alibabacloud/nlb/model/CreateLoadBalancerResult.h
+	include/alibabacloud/nlb/model/CreateSecurityPolicyRequest.h
+	include/alibabacloud/nlb/model/CreateSecurityPolicyResult.h
+	include/alibabacloud/nlb/model/CreateServerGroupRequest.h
+	include/alibabacloud/nlb/model/CreateServerGroupResult.h
+	include/alibabacloud/nlb/model/DeleteListenerRequest.h
+	include/alibabacloud/nlb/model/DeleteListenerResult.h
+	include/alibabacloud/nlb/model/DeleteLoadBalancerRequest.h
+	include/alibabacloud/nlb/model/DeleteLoadBalancerResult.h
+	include/alibabacloud/nlb/model/DeleteSecurityPolicyRequest.h
+	include/alibabacloud/nlb/model/DeleteSecurityPolicyResult.h
+	include/alibabacloud/nlb/model/DeleteServerGroupRequest.h
+	include/alibabacloud/nlb/model/DeleteServerGroupResult.h
+	include/alibabacloud/nlb/model/DescribeRegionsRequest.h
+	include/alibabacloud/nlb/model/DescribeRegionsResult.h
+	include/alibabacloud/nlb/model/DescribeZonesRequest.h
+	include/alibabacloud/nlb/model/DescribeZonesResult.h
+	include/alibabacloud/nlb/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.h
+	include/alibabacloud/nlb/model/DetachCommonBandwidthPackageFromLoadBalancerResult.h
+	include/alibabacloud/nlb/model/DisableLoadBalancerIpv6InternetRequest.h
+	include/alibabacloud/nlb/model/DisableLoadBalancerIpv6InternetResult.h
+	include/alibabacloud/nlb/model/DisassociateAdditionalCertificatesWithListenerRequest.h
+	include/alibabacloud/nlb/model/DisassociateAdditionalCertificatesWithListenerResult.h
+	include/alibabacloud/nlb/model/EnableLoadBalancerIpv6InternetRequest.h
+	include/alibabacloud/nlb/model/EnableLoadBalancerIpv6InternetResult.h
+	include/alibabacloud/nlb/model/GetJobStatusRequest.h
+	include/alibabacloud/nlb/model/GetJobStatusResult.h
+	include/alibabacloud/nlb/model/GetListenerAttributeRequest.h
+	include/alibabacloud/nlb/model/GetListenerAttributeResult.h
+	include/alibabacloud/nlb/model/GetListenerHealthStatusRequest.h
+	include/alibabacloud/nlb/model/GetListenerHealthStatusResult.h
+	include/alibabacloud/nlb/model/GetLoadBalancerAttributeRequest.h
+	include/alibabacloud/nlb/model/GetLoadBalancerAttributeResult.h
+	include/alibabacloud/nlb/model/ListListenerCertificatesRequest.h
+	include/alibabacloud/nlb/model/ListListenerCertificatesResult.h
+	include/alibabacloud/nlb/model/ListListenersRequest.h
+	include/alibabacloud/nlb/model/ListListenersResult.h
+	include/alibabacloud/nlb/model/ListLoadBalancersRequest.h
+	include/alibabacloud/nlb/model/ListLoadBalancersResult.h
+	include/alibabacloud/nlb/model/ListSecurityPolicyRequest.h
+	include/alibabacloud/nlb/model/ListSecurityPolicyResult.h
+	include/alibabacloud/nlb/model/ListServerGroupServersRequest.h
+	include/alibabacloud/nlb/model/ListServerGroupServersResult.h
+	include/alibabacloud/nlb/model/ListServerGroupsRequest.h
+	include/alibabacloud/nlb/model/ListServerGroupsResult.h
+	include/alibabacloud/nlb/model/ListSystemSecurityPolicyRequest.h
+	include/alibabacloud/nlb/model/ListSystemSecurityPolicyResult.h
+	include/alibabacloud/nlb/model/ListTagResourcesRequest.h
+	include/alibabacloud/nlb/model/ListTagResourcesResult.h
+	include/alibabacloud/nlb/model/LoadBalancerJoinSecurityGroupRequest.h
+	include/alibabacloud/nlb/model/LoadBalancerJoinSecurityGroupResult.h
+	include/alibabacloud/nlb/model/LoadBalancerLeaveSecurityGroupRequest.h
+	include/alibabacloud/nlb/model/LoadBalancerLeaveSecurityGroupResult.h
+	include/alibabacloud/nlb/model/MoveResourceGroupRequest.h
+	include/alibabacloud/nlb/model/MoveResourceGroupResult.h
+	include/alibabacloud/nlb/model/RemoveServersFromServerGroupRequest.h
+	include/alibabacloud/nlb/model/RemoveServersFromServerGroupResult.h
+	include/alibabacloud/nlb/model/StartListenerRequest.h
+	include/alibabacloud/nlb/model/StartListenerResult.h
+	include/alibabacloud/nlb/model/StartShiftLoadBalancerZonesRequest.h
+	include/alibabacloud/nlb/model/StartShiftLoadBalancerZonesResult.h
+	include/alibabacloud/nlb/model/StopListenerRequest.h
+	include/alibabacloud/nlb/model/StopListenerResult.h
+	include/alibabacloud/nlb/model/TagResourcesRequest.h
+	include/alibabacloud/nlb/model/TagResourcesResult.h
+	include/alibabacloud/nlb/model/UntagResourcesRequest.h
+	include/alibabacloud/nlb/model/UntagResourcesResult.h
+	include/alibabacloud/nlb/model/UpdateListenerAttributeRequest.h
+	include/alibabacloud/nlb/model/UpdateListenerAttributeResult.h
+	include/alibabacloud/nlb/model/UpdateLoadBalancerAddressTypeConfigRequest.h
+	include/alibabacloud/nlb/model/UpdateLoadBalancerAddressTypeConfigResult.h
+	include/alibabacloud/nlb/model/UpdateLoadBalancerAttributeRequest.h
+	include/alibabacloud/nlb/model/UpdateLoadBalancerAttributeResult.h
+	include/alibabacloud/nlb/model/UpdateLoadBalancerProtectionRequest.h
+	include/alibabacloud/nlb/model/UpdateLoadBalancerProtectionResult.h
+	include/alibabacloud/nlb/model/UpdateLoadBalancerZonesRequest.h
+	include/alibabacloud/nlb/model/UpdateLoadBalancerZonesResult.h
+	include/alibabacloud/nlb/model/UpdateSecurityPolicyAttributeRequest.h
+	include/alibabacloud/nlb/model/UpdateSecurityPolicyAttributeResult.h
+	include/alibabacloud/nlb/model/UpdateServerGroupAttributeRequest.h
+	include/alibabacloud/nlb/model/UpdateServerGroupAttributeResult.h
+	include/alibabacloud/nlb/model/UpdateServerGroupServersAttributeRequest.h
+	include/alibabacloud/nlb/model/UpdateServerGroupServersAttributeResult.h )
+
+set(nlb_src 
+	src/NlbClient.cc
+	src/model/AddServersToServerGroupRequest.cc
+	src/model/AddServersToServerGroupResult.cc
+	src/model/AssociateAdditionalCertificatesWithListenerRequest.cc
+	src/model/AssociateAdditionalCertificatesWithListenerResult.cc
+	src/model/AttachCommonBandwidthPackageToLoadBalancerRequest.cc
+	src/model/AttachCommonBandwidthPackageToLoadBalancerResult.cc
+	src/model/CancelShiftLoadBalancerZonesRequest.cc
+	src/model/CancelShiftLoadBalancerZonesResult.cc
+	src/model/CreateListenerRequest.cc
+	src/model/CreateListenerResult.cc
+	src/model/CreateLoadBalancerRequest.cc
+	src/model/CreateLoadBalancerResult.cc
+	src/model/CreateSecurityPolicyRequest.cc
+	src/model/CreateSecurityPolicyResult.cc
+	src/model/CreateServerGroupRequest.cc
+	src/model/CreateServerGroupResult.cc
+	src/model/DeleteListenerRequest.cc
+	src/model/DeleteListenerResult.cc
+	src/model/DeleteLoadBalancerRequest.cc
+	src/model/DeleteLoadBalancerResult.cc
+	src/model/DeleteSecurityPolicyRequest.cc
+	src/model/DeleteSecurityPolicyResult.cc
+	src/model/DeleteServerGroupRequest.cc
+	src/model/DeleteServerGroupResult.cc
+	src/model/DescribeRegionsRequest.cc
+	src/model/DescribeRegionsResult.cc
+	src/model/DescribeZonesRequest.cc
+	src/model/DescribeZonesResult.cc
+	src/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.cc
+	src/model/DetachCommonBandwidthPackageFromLoadBalancerResult.cc
+	src/model/DisableLoadBalancerIpv6InternetRequest.cc
+	src/model/DisableLoadBalancerIpv6InternetResult.cc
+	src/model/DisassociateAdditionalCertificatesWithListenerRequest.cc
+	src/model/DisassociateAdditionalCertificatesWithListenerResult.cc
+	src/model/EnableLoadBalancerIpv6InternetRequest.cc
+	src/model/EnableLoadBalancerIpv6InternetResult.cc
+	src/model/GetJobStatusRequest.cc
+	src/model/GetJobStatusResult.cc
+	src/model/GetListenerAttributeRequest.cc
+	src/model/GetListenerAttributeResult.cc
+	src/model/GetListenerHealthStatusRequest.cc
+	src/model/GetListenerHealthStatusResult.cc
+	src/model/GetLoadBalancerAttributeRequest.cc
+	src/model/GetLoadBalancerAttributeResult.cc
+	src/model/ListListenerCertificatesRequest.cc
+	src/model/ListListenerCertificatesResult.cc
+	src/model/ListListenersRequest.cc
+	src/model/ListListenersResult.cc
+	src/model/ListLoadBalancersRequest.cc
+	src/model/ListLoadBalancersResult.cc
+	src/model/ListSecurityPolicyRequest.cc
+	src/model/ListSecurityPolicyResult.cc
+	src/model/ListServerGroupServersRequest.cc
+	src/model/ListServerGroupServersResult.cc
+	src/model/ListServerGroupsRequest.cc
+	src/model/ListServerGroupsResult.cc
+	src/model/ListSystemSecurityPolicyRequest.cc
+	src/model/ListSystemSecurityPolicyResult.cc
+	src/model/ListTagResourcesRequest.cc
+	src/model/ListTagResourcesResult.cc
+	src/model/LoadBalancerJoinSecurityGroupRequest.cc
+	src/model/LoadBalancerJoinSecurityGroupResult.cc
+	src/model/LoadBalancerLeaveSecurityGroupRequest.cc
+	src/model/LoadBalancerLeaveSecurityGroupResult.cc
+	src/model/MoveResourceGroupRequest.cc
+	src/model/MoveResourceGroupResult.cc
+	src/model/RemoveServersFromServerGroupRequest.cc
+	src/model/RemoveServersFromServerGroupResult.cc
+	src/model/StartListenerRequest.cc
+	src/model/StartListenerResult.cc
+	src/model/StartShiftLoadBalancerZonesRequest.cc
+	src/model/StartShiftLoadBalancerZonesResult.cc
+	src/model/StopListenerRequest.cc
+	src/model/StopListenerResult.cc
+	src/model/TagResourcesRequest.cc
+	src/model/TagResourcesResult.cc
+	src/model/UntagResourcesRequest.cc
+	src/model/UntagResourcesResult.cc
+	src/model/UpdateListenerAttributeRequest.cc
+	src/model/UpdateListenerAttributeResult.cc
+	src/model/UpdateLoadBalancerAddressTypeConfigRequest.cc
+	src/model/UpdateLoadBalancerAddressTypeConfigResult.cc
+	src/model/UpdateLoadBalancerAttributeRequest.cc
+	src/model/UpdateLoadBalancerAttributeResult.cc
+	src/model/UpdateLoadBalancerProtectionRequest.cc
+	src/model/UpdateLoadBalancerProtectionResult.cc
+	src/model/UpdateLoadBalancerZonesRequest.cc
+	src/model/UpdateLoadBalancerZonesResult.cc
+	src/model/UpdateSecurityPolicyAttributeRequest.cc
+	src/model/UpdateSecurityPolicyAttributeResult.cc
+	src/model/UpdateServerGroupAttributeRequest.cc
+	src/model/UpdateServerGroupAttributeResult.cc
+	src/model/UpdateServerGroupServersAttributeRequest.cc
+	src/model/UpdateServerGroupServersAttributeResult.cc )
+
+add_library(nlb ${LIB_TYPE}
+	${nlb_public_header}
+	${nlb_public_header_model}
+	${nlb_src})
+
+set_target_properties(nlb
+	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}nlb
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(nlb
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_NLB_LIBRARY)
+endif()
+
+target_include_directories(nlb
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(nlb
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(nlb
+		jsoncpp)
+	target_include_directories(nlb
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(nlb
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(nlb
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(nlb
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(nlb
+		jsoncpp)
+endif()
+
+install(FILES ${nlb_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/nlb)
+install(FILES ${nlb_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/nlb/model)
+install(TARGETS nlb
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

nlb/include/alibabacloud/nlb/NlbClient.h

@@ -0,0 +1,422 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_NLBCLIENT_H_
+#define ALIBABACLOUD_NLB_NLBCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "NlbExport.h"
+#include "model/AddServersToServerGroupRequest.h"
+#include "model/AddServersToServerGroupResult.h"
+#include "model/AssociateAdditionalCertificatesWithListenerRequest.h"
+#include "model/AssociateAdditionalCertificatesWithListenerResult.h"
+#include "model/AttachCommonBandwidthPackageToLoadBalancerRequest.h"
+#include "model/AttachCommonBandwidthPackageToLoadBalancerResult.h"
+#include "model/CancelShiftLoadBalancerZonesRequest.h"
+#include "model/CancelShiftLoadBalancerZonesResult.h"
+#include "model/CreateListenerRequest.h"
+#include "model/CreateListenerResult.h"
+#include "model/CreateLoadBalancerRequest.h"
+#include "model/CreateLoadBalancerResult.h"
+#include "model/CreateSecurityPolicyRequest.h"
+#include "model/CreateSecurityPolicyResult.h"
+#include "model/CreateServerGroupRequest.h"
+#include "model/CreateServerGroupResult.h"
+#include "model/DeleteListenerRequest.h"
+#include "model/DeleteListenerResult.h"
+#include "model/DeleteLoadBalancerRequest.h"
+#include "model/DeleteLoadBalancerResult.h"
+#include "model/DeleteSecurityPolicyRequest.h"
+#include "model/DeleteSecurityPolicyResult.h"
+#include "model/DeleteServerGroupRequest.h"
+#include "model/DeleteServerGroupResult.h"
+#include "model/DescribeRegionsRequest.h"
+#include "model/DescribeRegionsResult.h"
+#include "model/DescribeZonesRequest.h"
+#include "model/DescribeZonesResult.h"
+#include "model/DetachCommonBandwidthPackageFromLoadBalancerRequest.h"
+#include "model/DetachCommonBandwidthPackageFromLoadBalancerResult.h"
+#include "model/DisableLoadBalancerIpv6InternetRequest.h"
+#include "model/DisableLoadBalancerIpv6InternetResult.h"
+#include "model/DisassociateAdditionalCertificatesWithListenerRequest.h"
+#include "model/DisassociateAdditionalCertificatesWithListenerResult.h"
+#include "model/EnableLoadBalancerIpv6InternetRequest.h"
+#include "model/EnableLoadBalancerIpv6InternetResult.h"
+#include "model/GetJobStatusRequest.h"
+#include "model/GetJobStatusResult.h"
+#include "model/GetListenerAttributeRequest.h"
+#include "model/GetListenerAttributeResult.h"
+#include "model/GetListenerHealthStatusRequest.h"
+#include "model/GetListenerHealthStatusResult.h"
+#include "model/GetLoadBalancerAttributeRequest.h"
+#include "model/GetLoadBalancerAttributeResult.h"
+#include "model/ListListenerCertificatesRequest.h"
+#include "model/ListListenerCertificatesResult.h"
+#include "model/ListListenersRequest.h"
+#include "model/ListListenersResult.h"
+#include "model/ListLoadBalancersRequest.h"
+#include "model/ListLoadBalancersResult.h"
+#include "model/ListSecurityPolicyRequest.h"
+#include "model/ListSecurityPolicyResult.h"
+#include "model/ListServerGroupServersRequest.h"
+#include "model/ListServerGroupServersResult.h"
+#include "model/ListServerGroupsRequest.h"
+#include "model/ListServerGroupsResult.h"
+#include "model/ListSystemSecurityPolicyRequest.h"
+#include "model/ListSystemSecurityPolicyResult.h"
+#include "model/ListTagResourcesRequest.h"
+#include "model/ListTagResourcesResult.h"
+#include "model/LoadBalancerJoinSecurityGroupRequest.h"
+#include "model/LoadBalancerJoinSecurityGroupResult.h"
+#include "model/LoadBalancerLeaveSecurityGroupRequest.h"
+#include "model/LoadBalancerLeaveSecurityGroupResult.h"
+#include "model/MoveResourceGroupRequest.h"
+#include "model/MoveResourceGroupResult.h"
+#include "model/RemoveServersFromServerGroupRequest.h"
+#include "model/RemoveServersFromServerGroupResult.h"
+#include "model/StartListenerRequest.h"
+#include "model/StartListenerResult.h"
+#include "model/StartShiftLoadBalancerZonesRequest.h"
+#include "model/StartShiftLoadBalancerZonesResult.h"
+#include "model/StopListenerRequest.h"
+#include "model/StopListenerResult.h"
+#include "model/TagResourcesRequest.h"
+#include "model/TagResourcesResult.h"
+#include "model/UntagResourcesRequest.h"
+#include "model/UntagResourcesResult.h"
+#include "model/UpdateListenerAttributeRequest.h"
+#include "model/UpdateListenerAttributeResult.h"
+#include "model/UpdateLoadBalancerAddressTypeConfigRequest.h"
+#include "model/UpdateLoadBalancerAddressTypeConfigResult.h"
+#include "model/UpdateLoadBalancerAttributeRequest.h"
+#include "model/UpdateLoadBalancerAttributeResult.h"
+#include "model/UpdateLoadBalancerProtectionRequest.h"
+#include "model/UpdateLoadBalancerProtectionResult.h"
+#include "model/UpdateLoadBalancerZonesRequest.h"
+#include "model/UpdateLoadBalancerZonesResult.h"
+#include "model/UpdateSecurityPolicyAttributeRequest.h"
+#include "model/UpdateSecurityPolicyAttributeResult.h"
+#include "model/UpdateServerGroupAttributeRequest.h"
+#include "model/UpdateServerGroupAttributeResult.h"
+#include "model/UpdateServerGroupServersAttributeRequest.h"
+#include "model/UpdateServerGroupServersAttributeResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		class ALIBABACLOUD_NLB_EXPORT NlbClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::AddServersToServerGroupResult> AddServersToServerGroupOutcome;
+			typedef std::future<AddServersToServerGroupOutcome> AddServersToServerGroupOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::AddServersToServerGroupRequest&, const AddServersToServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddServersToServerGroupAsyncHandler;
+			typedef Outcome<Error, Model::AssociateAdditionalCertificatesWithListenerResult> AssociateAdditionalCertificatesWithListenerOutcome;
+			typedef std::future<AssociateAdditionalCertificatesWithListenerOutcome> AssociateAdditionalCertificatesWithListenerOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::AssociateAdditionalCertificatesWithListenerRequest&, const AssociateAdditionalCertificatesWithListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssociateAdditionalCertificatesWithListenerAsyncHandler;
+			typedef Outcome<Error, Model::AttachCommonBandwidthPackageToLoadBalancerResult> AttachCommonBandwidthPackageToLoadBalancerOutcome;
+			typedef std::future<AttachCommonBandwidthPackageToLoadBalancerOutcome> AttachCommonBandwidthPackageToLoadBalancerOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::AttachCommonBandwidthPackageToLoadBalancerRequest&, const AttachCommonBandwidthPackageToLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachCommonBandwidthPackageToLoadBalancerAsyncHandler;
+			typedef Outcome<Error, Model::CancelShiftLoadBalancerZonesResult> CancelShiftLoadBalancerZonesOutcome;
+			typedef std::future<CancelShiftLoadBalancerZonesOutcome> CancelShiftLoadBalancerZonesOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::CancelShiftLoadBalancerZonesRequest&, const CancelShiftLoadBalancerZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelShiftLoadBalancerZonesAsyncHandler;
+			typedef Outcome<Error, Model::CreateListenerResult> CreateListenerOutcome;
+			typedef std::future<CreateListenerOutcome> CreateListenerOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::CreateListenerRequest&, const CreateListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateListenerAsyncHandler;
+			typedef Outcome<Error, Model::CreateLoadBalancerResult> CreateLoadBalancerOutcome;
+			typedef std::future<CreateLoadBalancerOutcome> CreateLoadBalancerOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::CreateLoadBalancerRequest&, const CreateLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLoadBalancerAsyncHandler;
+			typedef Outcome<Error, Model::CreateSecurityPolicyResult> CreateSecurityPolicyOutcome;
+			typedef std::future<CreateSecurityPolicyOutcome> CreateSecurityPolicyOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::CreateSecurityPolicyRequest&, const CreateSecurityPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSecurityPolicyAsyncHandler;
+			typedef Outcome<Error, Model::CreateServerGroupResult> CreateServerGroupOutcome;
+			typedef std::future<CreateServerGroupOutcome> CreateServerGroupOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::CreateServerGroupRequest&, const CreateServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateServerGroupAsyncHandler;
+			typedef Outcome<Error, Model::DeleteListenerResult> DeleteListenerOutcome;
+			typedef std::future<DeleteListenerOutcome> DeleteListenerOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::DeleteListenerRequest&, const DeleteListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteListenerAsyncHandler;
+			typedef Outcome<Error, Model::DeleteLoadBalancerResult> DeleteLoadBalancerOutcome;
+			typedef std::future<DeleteLoadBalancerOutcome> DeleteLoadBalancerOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::DeleteLoadBalancerRequest&, const DeleteLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLoadBalancerAsyncHandler;
+			typedef Outcome<Error, Model::DeleteSecurityPolicyResult> DeleteSecurityPolicyOutcome;
+			typedef std::future<DeleteSecurityPolicyOutcome> DeleteSecurityPolicyOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::DeleteSecurityPolicyRequest&, const DeleteSecurityPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSecurityPolicyAsyncHandler;
+			typedef Outcome<Error, Model::DeleteServerGroupResult> DeleteServerGroupOutcome;
+			typedef std::future<DeleteServerGroupOutcome> DeleteServerGroupOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::DeleteServerGroupRequest&, const DeleteServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteServerGroupAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
+			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
+			typedef std::function<void(const NlbClient*, 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 NlbClient*, const Model::DescribeZonesRequest&, const DescribeZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeZonesAsyncHandler;
+			typedef Outcome<Error, Model::DetachCommonBandwidthPackageFromLoadBalancerResult> DetachCommonBandwidthPackageFromLoadBalancerOutcome;
+			typedef std::future<DetachCommonBandwidthPackageFromLoadBalancerOutcome> DetachCommonBandwidthPackageFromLoadBalancerOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::DetachCommonBandwidthPackageFromLoadBalancerRequest&, const DetachCommonBandwidthPackageFromLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachCommonBandwidthPackageFromLoadBalancerAsyncHandler;
+			typedef Outcome<Error, Model::DisableLoadBalancerIpv6InternetResult> DisableLoadBalancerIpv6InternetOutcome;
+			typedef std::future<DisableLoadBalancerIpv6InternetOutcome> DisableLoadBalancerIpv6InternetOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::DisableLoadBalancerIpv6InternetRequest&, const DisableLoadBalancerIpv6InternetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableLoadBalancerIpv6InternetAsyncHandler;
+			typedef Outcome<Error, Model::DisassociateAdditionalCertificatesWithListenerResult> DisassociateAdditionalCertificatesWithListenerOutcome;
+			typedef std::future<DisassociateAdditionalCertificatesWithListenerOutcome> DisassociateAdditionalCertificatesWithListenerOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::DisassociateAdditionalCertificatesWithListenerRequest&, const DisassociateAdditionalCertificatesWithListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisassociateAdditionalCertificatesWithListenerAsyncHandler;
+			typedef Outcome<Error, Model::EnableLoadBalancerIpv6InternetResult> EnableLoadBalancerIpv6InternetOutcome;
+			typedef std::future<EnableLoadBalancerIpv6InternetOutcome> EnableLoadBalancerIpv6InternetOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::EnableLoadBalancerIpv6InternetRequest&, const EnableLoadBalancerIpv6InternetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableLoadBalancerIpv6InternetAsyncHandler;
+			typedef Outcome<Error, Model::GetJobStatusResult> GetJobStatusOutcome;
+			typedef std::future<GetJobStatusOutcome> GetJobStatusOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::GetJobStatusRequest&, const GetJobStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetJobStatusAsyncHandler;
+			typedef Outcome<Error, Model::GetListenerAttributeResult> GetListenerAttributeOutcome;
+			typedef std::future<GetListenerAttributeOutcome> GetListenerAttributeOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::GetListenerAttributeRequest&, const GetListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetListenerAttributeAsyncHandler;
+			typedef Outcome<Error, Model::GetListenerHealthStatusResult> GetListenerHealthStatusOutcome;
+			typedef std::future<GetListenerHealthStatusOutcome> GetListenerHealthStatusOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::GetListenerHealthStatusRequest&, const GetListenerHealthStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetListenerHealthStatusAsyncHandler;
+			typedef Outcome<Error, Model::GetLoadBalancerAttributeResult> GetLoadBalancerAttributeOutcome;
+			typedef std::future<GetLoadBalancerAttributeOutcome> GetLoadBalancerAttributeOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::GetLoadBalancerAttributeRequest&, const GetLoadBalancerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLoadBalancerAttributeAsyncHandler;
+			typedef Outcome<Error, Model::ListListenerCertificatesResult> ListListenerCertificatesOutcome;
+			typedef std::future<ListListenerCertificatesOutcome> ListListenerCertificatesOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::ListListenerCertificatesRequest&, const ListListenerCertificatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListListenerCertificatesAsyncHandler;
+			typedef Outcome<Error, Model::ListListenersResult> ListListenersOutcome;
+			typedef std::future<ListListenersOutcome> ListListenersOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::ListListenersRequest&, const ListListenersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListListenersAsyncHandler;
+			typedef Outcome<Error, Model::ListLoadBalancersResult> ListLoadBalancersOutcome;
+			typedef std::future<ListLoadBalancersOutcome> ListLoadBalancersOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::ListLoadBalancersRequest&, const ListLoadBalancersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListLoadBalancersAsyncHandler;
+			typedef Outcome<Error, Model::ListSecurityPolicyResult> ListSecurityPolicyOutcome;
+			typedef std::future<ListSecurityPolicyOutcome> ListSecurityPolicyOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::ListSecurityPolicyRequest&, const ListSecurityPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSecurityPolicyAsyncHandler;
+			typedef Outcome<Error, Model::ListServerGroupServersResult> ListServerGroupServersOutcome;
+			typedef std::future<ListServerGroupServersOutcome> ListServerGroupServersOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::ListServerGroupServersRequest&, const ListServerGroupServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListServerGroupServersAsyncHandler;
+			typedef Outcome<Error, Model::ListServerGroupsResult> ListServerGroupsOutcome;
+			typedef std::future<ListServerGroupsOutcome> ListServerGroupsOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::ListServerGroupsRequest&, const ListServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListServerGroupsAsyncHandler;
+			typedef Outcome<Error, Model::ListSystemSecurityPolicyResult> ListSystemSecurityPolicyOutcome;
+			typedef std::future<ListSystemSecurityPolicyOutcome> ListSystemSecurityPolicyOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::ListSystemSecurityPolicyRequest&, const ListSystemSecurityPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSystemSecurityPolicyAsyncHandler;
+			typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
+			typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
+			typedef Outcome<Error, Model::LoadBalancerJoinSecurityGroupResult> LoadBalancerJoinSecurityGroupOutcome;
+			typedef std::future<LoadBalancerJoinSecurityGroupOutcome> LoadBalancerJoinSecurityGroupOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::LoadBalancerJoinSecurityGroupRequest&, const LoadBalancerJoinSecurityGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> LoadBalancerJoinSecurityGroupAsyncHandler;
+			typedef Outcome<Error, Model::LoadBalancerLeaveSecurityGroupResult> LoadBalancerLeaveSecurityGroupOutcome;
+			typedef std::future<LoadBalancerLeaveSecurityGroupOutcome> LoadBalancerLeaveSecurityGroupOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::LoadBalancerLeaveSecurityGroupRequest&, const LoadBalancerLeaveSecurityGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> LoadBalancerLeaveSecurityGroupAsyncHandler;
+			typedef Outcome<Error, Model::MoveResourceGroupResult> MoveResourceGroupOutcome;
+			typedef std::future<MoveResourceGroupOutcome> MoveResourceGroupOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::MoveResourceGroupRequest&, const MoveResourceGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoveResourceGroupAsyncHandler;
+			typedef Outcome<Error, Model::RemoveServersFromServerGroupResult> RemoveServersFromServerGroupOutcome;
+			typedef std::future<RemoveServersFromServerGroupOutcome> RemoveServersFromServerGroupOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::RemoveServersFromServerGroupRequest&, const RemoveServersFromServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveServersFromServerGroupAsyncHandler;
+			typedef Outcome<Error, Model::StartListenerResult> StartListenerOutcome;
+			typedef std::future<StartListenerOutcome> StartListenerOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::StartListenerRequest&, const StartListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartListenerAsyncHandler;
+			typedef Outcome<Error, Model::StartShiftLoadBalancerZonesResult> StartShiftLoadBalancerZonesOutcome;
+			typedef std::future<StartShiftLoadBalancerZonesOutcome> StartShiftLoadBalancerZonesOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::StartShiftLoadBalancerZonesRequest&, const StartShiftLoadBalancerZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartShiftLoadBalancerZonesAsyncHandler;
+			typedef Outcome<Error, Model::StopListenerResult> StopListenerOutcome;
+			typedef std::future<StopListenerOutcome> StopListenerOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::StopListenerRequest&, const StopListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopListenerAsyncHandler;
+			typedef Outcome<Error, Model::TagResourcesResult> TagResourcesOutcome;
+			typedef std::future<TagResourcesOutcome> TagResourcesOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::TagResourcesRequest&, const TagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagResourcesAsyncHandler;
+			typedef Outcome<Error, Model::UntagResourcesResult> UntagResourcesOutcome;
+			typedef std::future<UntagResourcesOutcome> UntagResourcesOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::UntagResourcesRequest&, const UntagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UntagResourcesAsyncHandler;
+			typedef Outcome<Error, Model::UpdateListenerAttributeResult> UpdateListenerAttributeOutcome;
+			typedef std::future<UpdateListenerAttributeOutcome> UpdateListenerAttributeOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::UpdateListenerAttributeRequest&, const UpdateListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateListenerAttributeAsyncHandler;
+			typedef Outcome<Error, Model::UpdateLoadBalancerAddressTypeConfigResult> UpdateLoadBalancerAddressTypeConfigOutcome;
+			typedef std::future<UpdateLoadBalancerAddressTypeConfigOutcome> UpdateLoadBalancerAddressTypeConfigOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::UpdateLoadBalancerAddressTypeConfigRequest&, const UpdateLoadBalancerAddressTypeConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLoadBalancerAddressTypeConfigAsyncHandler;
+			typedef Outcome<Error, Model::UpdateLoadBalancerAttributeResult> UpdateLoadBalancerAttributeOutcome;
+			typedef std::future<UpdateLoadBalancerAttributeOutcome> UpdateLoadBalancerAttributeOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::UpdateLoadBalancerAttributeRequest&, const UpdateLoadBalancerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLoadBalancerAttributeAsyncHandler;
+			typedef Outcome<Error, Model::UpdateLoadBalancerProtectionResult> UpdateLoadBalancerProtectionOutcome;
+			typedef std::future<UpdateLoadBalancerProtectionOutcome> UpdateLoadBalancerProtectionOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::UpdateLoadBalancerProtectionRequest&, const UpdateLoadBalancerProtectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLoadBalancerProtectionAsyncHandler;
+			typedef Outcome<Error, Model::UpdateLoadBalancerZonesResult> UpdateLoadBalancerZonesOutcome;
+			typedef std::future<UpdateLoadBalancerZonesOutcome> UpdateLoadBalancerZonesOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::UpdateLoadBalancerZonesRequest&, const UpdateLoadBalancerZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLoadBalancerZonesAsyncHandler;
+			typedef Outcome<Error, Model::UpdateSecurityPolicyAttributeResult> UpdateSecurityPolicyAttributeOutcome;
+			typedef std::future<UpdateSecurityPolicyAttributeOutcome> UpdateSecurityPolicyAttributeOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::UpdateSecurityPolicyAttributeRequest&, const UpdateSecurityPolicyAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateSecurityPolicyAttributeAsyncHandler;
+			typedef Outcome<Error, Model::UpdateServerGroupAttributeResult> UpdateServerGroupAttributeOutcome;
+			typedef std::future<UpdateServerGroupAttributeOutcome> UpdateServerGroupAttributeOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::UpdateServerGroupAttributeRequest&, const UpdateServerGroupAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateServerGroupAttributeAsyncHandler;
+			typedef Outcome<Error, Model::UpdateServerGroupServersAttributeResult> UpdateServerGroupServersAttributeOutcome;
+			typedef std::future<UpdateServerGroupServersAttributeOutcome> UpdateServerGroupServersAttributeOutcomeCallable;
+			typedef std::function<void(const NlbClient*, const Model::UpdateServerGroupServersAttributeRequest&, const UpdateServerGroupServersAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateServerGroupServersAttributeAsyncHandler;
+
+			NlbClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			NlbClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			NlbClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~NlbClient();
+			AddServersToServerGroupOutcome addServersToServerGroup(const Model::AddServersToServerGroupRequest &request)const;
+			void addServersToServerGroupAsync(const Model::AddServersToServerGroupRequest& request, const AddServersToServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddServersToServerGroupOutcomeCallable addServersToServerGroupCallable(const Model::AddServersToServerGroupRequest& request) const;
+			AssociateAdditionalCertificatesWithListenerOutcome associateAdditionalCertificatesWithListener(const Model::AssociateAdditionalCertificatesWithListenerRequest &request)const;
+			void associateAdditionalCertificatesWithListenerAsync(const Model::AssociateAdditionalCertificatesWithListenerRequest& request, const AssociateAdditionalCertificatesWithListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AssociateAdditionalCertificatesWithListenerOutcomeCallable associateAdditionalCertificatesWithListenerCallable(const Model::AssociateAdditionalCertificatesWithListenerRequest& request) const;
+			AttachCommonBandwidthPackageToLoadBalancerOutcome attachCommonBandwidthPackageToLoadBalancer(const Model::AttachCommonBandwidthPackageToLoadBalancerRequest &request)const;
+			void attachCommonBandwidthPackageToLoadBalancerAsync(const Model::AttachCommonBandwidthPackageToLoadBalancerRequest& request, const AttachCommonBandwidthPackageToLoadBalancerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AttachCommonBandwidthPackageToLoadBalancerOutcomeCallable attachCommonBandwidthPackageToLoadBalancerCallable(const Model::AttachCommonBandwidthPackageToLoadBalancerRequest& request) const;
+			CancelShiftLoadBalancerZonesOutcome cancelShiftLoadBalancerZones(const Model::CancelShiftLoadBalancerZonesRequest &request)const;
+			void cancelShiftLoadBalancerZonesAsync(const Model::CancelShiftLoadBalancerZonesRequest& request, const CancelShiftLoadBalancerZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CancelShiftLoadBalancerZonesOutcomeCallable cancelShiftLoadBalancerZonesCallable(const Model::CancelShiftLoadBalancerZonesRequest& request) const;
+			CreateListenerOutcome createListener(const Model::CreateListenerRequest &request)const;
+			void createListenerAsync(const Model::CreateListenerRequest& request, const CreateListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateListenerOutcomeCallable createListenerCallable(const Model::CreateListenerRequest& request) const;
+			CreateLoadBalancerOutcome createLoadBalancer(const Model::CreateLoadBalancerRequest &request)const;
+			void createLoadBalancerAsync(const Model::CreateLoadBalancerRequest& request, const CreateLoadBalancerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateLoadBalancerOutcomeCallable createLoadBalancerCallable(const Model::CreateLoadBalancerRequest& request) const;
+			CreateSecurityPolicyOutcome createSecurityPolicy(const Model::CreateSecurityPolicyRequest &request)const;
+			void createSecurityPolicyAsync(const Model::CreateSecurityPolicyRequest& request, const CreateSecurityPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateSecurityPolicyOutcomeCallable createSecurityPolicyCallable(const Model::CreateSecurityPolicyRequest& request) const;
+			CreateServerGroupOutcome createServerGroup(const Model::CreateServerGroupRequest &request)const;
+			void createServerGroupAsync(const Model::CreateServerGroupRequest& request, const CreateServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateServerGroupOutcomeCallable createServerGroupCallable(const Model::CreateServerGroupRequest& request) const;
+			DeleteListenerOutcome deleteListener(const Model::DeleteListenerRequest &request)const;
+			void deleteListenerAsync(const Model::DeleteListenerRequest& request, const DeleteListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteListenerOutcomeCallable deleteListenerCallable(const Model::DeleteListenerRequest& request) const;
+			DeleteLoadBalancerOutcome deleteLoadBalancer(const Model::DeleteLoadBalancerRequest &request)const;
+			void deleteLoadBalancerAsync(const Model::DeleteLoadBalancerRequest& request, const DeleteLoadBalancerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteLoadBalancerOutcomeCallable deleteLoadBalancerCallable(const Model::DeleteLoadBalancerRequest& request) const;
+			DeleteSecurityPolicyOutcome deleteSecurityPolicy(const Model::DeleteSecurityPolicyRequest &request)const;
+			void deleteSecurityPolicyAsync(const Model::DeleteSecurityPolicyRequest& request, const DeleteSecurityPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteSecurityPolicyOutcomeCallable deleteSecurityPolicyCallable(const Model::DeleteSecurityPolicyRequest& request) const;
+			DeleteServerGroupOutcome deleteServerGroup(const Model::DeleteServerGroupRequest &request)const;
+			void deleteServerGroupAsync(const Model::DeleteServerGroupRequest& request, const DeleteServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteServerGroupOutcomeCallable deleteServerGroupCallable(const Model::DeleteServerGroupRequest& 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;
+			DetachCommonBandwidthPackageFromLoadBalancerOutcome detachCommonBandwidthPackageFromLoadBalancer(const Model::DetachCommonBandwidthPackageFromLoadBalancerRequest &request)const;
+			void detachCommonBandwidthPackageFromLoadBalancerAsync(const Model::DetachCommonBandwidthPackageFromLoadBalancerRequest& request, const DetachCommonBandwidthPackageFromLoadBalancerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetachCommonBandwidthPackageFromLoadBalancerOutcomeCallable detachCommonBandwidthPackageFromLoadBalancerCallable(const Model::DetachCommonBandwidthPackageFromLoadBalancerRequest& request) const;
+			DisableLoadBalancerIpv6InternetOutcome disableLoadBalancerIpv6Internet(const Model::DisableLoadBalancerIpv6InternetRequest &request)const;
+			void disableLoadBalancerIpv6InternetAsync(const Model::DisableLoadBalancerIpv6InternetRequest& request, const DisableLoadBalancerIpv6InternetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisableLoadBalancerIpv6InternetOutcomeCallable disableLoadBalancerIpv6InternetCallable(const Model::DisableLoadBalancerIpv6InternetRequest& request) const;
+			DisassociateAdditionalCertificatesWithListenerOutcome disassociateAdditionalCertificatesWithListener(const Model::DisassociateAdditionalCertificatesWithListenerRequest &request)const;
+			void disassociateAdditionalCertificatesWithListenerAsync(const Model::DisassociateAdditionalCertificatesWithListenerRequest& request, const DisassociateAdditionalCertificatesWithListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisassociateAdditionalCertificatesWithListenerOutcomeCallable disassociateAdditionalCertificatesWithListenerCallable(const Model::DisassociateAdditionalCertificatesWithListenerRequest& request) const;
+			EnableLoadBalancerIpv6InternetOutcome enableLoadBalancerIpv6Internet(const Model::EnableLoadBalancerIpv6InternetRequest &request)const;
+			void enableLoadBalancerIpv6InternetAsync(const Model::EnableLoadBalancerIpv6InternetRequest& request, const EnableLoadBalancerIpv6InternetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableLoadBalancerIpv6InternetOutcomeCallable enableLoadBalancerIpv6InternetCallable(const Model::EnableLoadBalancerIpv6InternetRequest& request) const;
+			GetJobStatusOutcome getJobStatus(const Model::GetJobStatusRequest &request)const;
+			void getJobStatusAsync(const Model::GetJobStatusRequest& request, const GetJobStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetJobStatusOutcomeCallable getJobStatusCallable(const Model::GetJobStatusRequest& request) const;
+			GetListenerAttributeOutcome getListenerAttribute(const Model::GetListenerAttributeRequest &request)const;
+			void getListenerAttributeAsync(const Model::GetListenerAttributeRequest& request, const GetListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetListenerAttributeOutcomeCallable getListenerAttributeCallable(const Model::GetListenerAttributeRequest& request) const;
+			GetListenerHealthStatusOutcome getListenerHealthStatus(const Model::GetListenerHealthStatusRequest &request)const;
+			void getListenerHealthStatusAsync(const Model::GetListenerHealthStatusRequest& request, const GetListenerHealthStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetListenerHealthStatusOutcomeCallable getListenerHealthStatusCallable(const Model::GetListenerHealthStatusRequest& request) const;
+			GetLoadBalancerAttributeOutcome getLoadBalancerAttribute(const Model::GetLoadBalancerAttributeRequest &request)const;
+			void getLoadBalancerAttributeAsync(const Model::GetLoadBalancerAttributeRequest& request, const GetLoadBalancerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetLoadBalancerAttributeOutcomeCallable getLoadBalancerAttributeCallable(const Model::GetLoadBalancerAttributeRequest& request) const;
+			ListListenerCertificatesOutcome listListenerCertificates(const Model::ListListenerCertificatesRequest &request)const;
+			void listListenerCertificatesAsync(const Model::ListListenerCertificatesRequest& request, const ListListenerCertificatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListListenerCertificatesOutcomeCallable listListenerCertificatesCallable(const Model::ListListenerCertificatesRequest& request) const;
+			ListListenersOutcome listListeners(const Model::ListListenersRequest &request)const;
+			void listListenersAsync(const Model::ListListenersRequest& request, const ListListenersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListListenersOutcomeCallable listListenersCallable(const Model::ListListenersRequest& request) const;
+			ListLoadBalancersOutcome listLoadBalancers(const Model::ListLoadBalancersRequest &request)const;
+			void listLoadBalancersAsync(const Model::ListLoadBalancersRequest& request, const ListLoadBalancersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListLoadBalancersOutcomeCallable listLoadBalancersCallable(const Model::ListLoadBalancersRequest& request) const;
+			ListSecurityPolicyOutcome listSecurityPolicy(const Model::ListSecurityPolicyRequest &request)const;
+			void listSecurityPolicyAsync(const Model::ListSecurityPolicyRequest& request, const ListSecurityPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSecurityPolicyOutcomeCallable listSecurityPolicyCallable(const Model::ListSecurityPolicyRequest& request) const;
+			ListServerGroupServersOutcome listServerGroupServers(const Model::ListServerGroupServersRequest &request)const;
+			void listServerGroupServersAsync(const Model::ListServerGroupServersRequest& request, const ListServerGroupServersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListServerGroupServersOutcomeCallable listServerGroupServersCallable(const Model::ListServerGroupServersRequest& request) const;
+			ListServerGroupsOutcome listServerGroups(const Model::ListServerGroupsRequest &request)const;
+			void listServerGroupsAsync(const Model::ListServerGroupsRequest& request, const ListServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListServerGroupsOutcomeCallable listServerGroupsCallable(const Model::ListServerGroupsRequest& request) const;
+			ListSystemSecurityPolicyOutcome listSystemSecurityPolicy(const Model::ListSystemSecurityPolicyRequest &request)const;
+			void listSystemSecurityPolicyAsync(const Model::ListSystemSecurityPolicyRequest& request, const ListSystemSecurityPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSystemSecurityPolicyOutcomeCallable listSystemSecurityPolicyCallable(const Model::ListSystemSecurityPolicyRequest& request) const;
+			ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
+			void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
+			LoadBalancerJoinSecurityGroupOutcome loadBalancerJoinSecurityGroup(const Model::LoadBalancerJoinSecurityGroupRequest &request)const;
+			void loadBalancerJoinSecurityGroupAsync(const Model::LoadBalancerJoinSecurityGroupRequest& request, const LoadBalancerJoinSecurityGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			LoadBalancerJoinSecurityGroupOutcomeCallable loadBalancerJoinSecurityGroupCallable(const Model::LoadBalancerJoinSecurityGroupRequest& request) const;
+			LoadBalancerLeaveSecurityGroupOutcome loadBalancerLeaveSecurityGroup(const Model::LoadBalancerLeaveSecurityGroupRequest &request)const;
+			void loadBalancerLeaveSecurityGroupAsync(const Model::LoadBalancerLeaveSecurityGroupRequest& request, const LoadBalancerLeaveSecurityGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			LoadBalancerLeaveSecurityGroupOutcomeCallable loadBalancerLeaveSecurityGroupCallable(const Model::LoadBalancerLeaveSecurityGroupRequest& request) const;
+			MoveResourceGroupOutcome moveResourceGroup(const Model::MoveResourceGroupRequest &request)const;
+			void moveResourceGroupAsync(const Model::MoveResourceGroupRequest& request, const MoveResourceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			MoveResourceGroupOutcomeCallable moveResourceGroupCallable(const Model::MoveResourceGroupRequest& request) const;
+			RemoveServersFromServerGroupOutcome removeServersFromServerGroup(const Model::RemoveServersFromServerGroupRequest &request)const;
+			void removeServersFromServerGroupAsync(const Model::RemoveServersFromServerGroupRequest& request, const RemoveServersFromServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveServersFromServerGroupOutcomeCallable removeServersFromServerGroupCallable(const Model::RemoveServersFromServerGroupRequest& request) const;
+			StartListenerOutcome startListener(const Model::StartListenerRequest &request)const;
+			void startListenerAsync(const Model::StartListenerRequest& request, const StartListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartListenerOutcomeCallable startListenerCallable(const Model::StartListenerRequest& request) const;
+			StartShiftLoadBalancerZonesOutcome startShiftLoadBalancerZones(const Model::StartShiftLoadBalancerZonesRequest &request)const;
+			void startShiftLoadBalancerZonesAsync(const Model::StartShiftLoadBalancerZonesRequest& request, const StartShiftLoadBalancerZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartShiftLoadBalancerZonesOutcomeCallable startShiftLoadBalancerZonesCallable(const Model::StartShiftLoadBalancerZonesRequest& request) const;
+			StopListenerOutcome stopListener(const Model::StopListenerRequest &request)const;
+			void stopListenerAsync(const Model::StopListenerRequest& request, const StopListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopListenerOutcomeCallable stopListenerCallable(const Model::StopListenerRequest& request) const;
+			TagResourcesOutcome tagResources(const Model::TagResourcesRequest &request)const;
+			void tagResourcesAsync(const Model::TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TagResourcesOutcomeCallable tagResourcesCallable(const Model::TagResourcesRequest& request) const;
+			UntagResourcesOutcome untagResources(const Model::UntagResourcesRequest &request)const;
+			void untagResourcesAsync(const Model::UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UntagResourcesOutcomeCallable untagResourcesCallable(const Model::UntagResourcesRequest& request) const;
+			UpdateListenerAttributeOutcome updateListenerAttribute(const Model::UpdateListenerAttributeRequest &request)const;
+			void updateListenerAttributeAsync(const Model::UpdateListenerAttributeRequest& request, const UpdateListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateListenerAttributeOutcomeCallable updateListenerAttributeCallable(const Model::UpdateListenerAttributeRequest& request) const;
+			UpdateLoadBalancerAddressTypeConfigOutcome updateLoadBalancerAddressTypeConfig(const Model::UpdateLoadBalancerAddressTypeConfigRequest &request)const;
+			void updateLoadBalancerAddressTypeConfigAsync(const Model::UpdateLoadBalancerAddressTypeConfigRequest& request, const UpdateLoadBalancerAddressTypeConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateLoadBalancerAddressTypeConfigOutcomeCallable updateLoadBalancerAddressTypeConfigCallable(const Model::UpdateLoadBalancerAddressTypeConfigRequest& request) const;
+			UpdateLoadBalancerAttributeOutcome updateLoadBalancerAttribute(const Model::UpdateLoadBalancerAttributeRequest &request)const;
+			void updateLoadBalancerAttributeAsync(const Model::UpdateLoadBalancerAttributeRequest& request, const UpdateLoadBalancerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateLoadBalancerAttributeOutcomeCallable updateLoadBalancerAttributeCallable(const Model::UpdateLoadBalancerAttributeRequest& request) const;
+			UpdateLoadBalancerProtectionOutcome updateLoadBalancerProtection(const Model::UpdateLoadBalancerProtectionRequest &request)const;
+			void updateLoadBalancerProtectionAsync(const Model::UpdateLoadBalancerProtectionRequest& request, const UpdateLoadBalancerProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateLoadBalancerProtectionOutcomeCallable updateLoadBalancerProtectionCallable(const Model::UpdateLoadBalancerProtectionRequest& request) const;
+			UpdateLoadBalancerZonesOutcome updateLoadBalancerZones(const Model::UpdateLoadBalancerZonesRequest &request)const;
+			void updateLoadBalancerZonesAsync(const Model::UpdateLoadBalancerZonesRequest& request, const UpdateLoadBalancerZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateLoadBalancerZonesOutcomeCallable updateLoadBalancerZonesCallable(const Model::UpdateLoadBalancerZonesRequest& request) const;
+			UpdateSecurityPolicyAttributeOutcome updateSecurityPolicyAttribute(const Model::UpdateSecurityPolicyAttributeRequest &request)const;
+			void updateSecurityPolicyAttributeAsync(const Model::UpdateSecurityPolicyAttributeRequest& request, const UpdateSecurityPolicyAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateSecurityPolicyAttributeOutcomeCallable updateSecurityPolicyAttributeCallable(const Model::UpdateSecurityPolicyAttributeRequest& request) const;
+			UpdateServerGroupAttributeOutcome updateServerGroupAttribute(const Model::UpdateServerGroupAttributeRequest &request)const;
+			void updateServerGroupAttributeAsync(const Model::UpdateServerGroupAttributeRequest& request, const UpdateServerGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateServerGroupAttributeOutcomeCallable updateServerGroupAttributeCallable(const Model::UpdateServerGroupAttributeRequest& request) const;
+			UpdateServerGroupServersAttributeOutcome updateServerGroupServersAttribute(const Model::UpdateServerGroupServersAttributeRequest &request)const;
+			void updateServerGroupServersAttributeAsync(const Model::UpdateServerGroupServersAttributeRequest& request, const UpdateServerGroupServersAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateServerGroupServersAttributeOutcomeCallable updateServerGroupServersAttributeCallable(const Model::UpdateServerGroupServersAttributeRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_NLB_NLBCLIENT_H_

nlb/include/alibabacloud/nlb/NlbExport.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_NLB_NLBEXPORT_H_
+#define ALIBABACLOUD_NLB_NLBEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_NLB_LIBRARY)
+#		define ALIBABACLOUD_NLB_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_NLB_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_NLB_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_NLB_NLBEXPORT_H_

nlb/include/alibabacloud/nlb/model/AddServersToServerGroupRequest.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_ADDSERVERSTOSERVERGROUPREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_ADDSERVERSTOSERVERGROUPREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT AddServersToServerGroupRequest : public RpcServiceRequest {
+public:
+	struct Servers {
+		std::string serverId;
+		std::string serverType;
+		std::string serverIp;
+		int port;
+		int weight;
+		std::string description;
+	};
+	AddServersToServerGroupRequest();
+	~AddServersToServerGroupRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getServerGroupId() const;
+	void setServerGroupId(const std::string &serverGroupId);
+	std::vector<Servers> getServers() const;
+	void setServers(const std::vector<Servers> &servers);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::string serverGroupId_;
+	std::vector<Servers> servers_;
+	std::string regionId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_ADDSERVERSTOSERVERGROUPREQUEST_H_

nlb/include/alibabacloud/nlb/model/AddServersToServerGroupResult.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_NLB_MODEL_ADDSERVERSTOSERVERGROUPRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_ADDSERVERSTOSERVERGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT AddServersToServerGroupResult : public ServiceResult
+			{
+			public:
+
+
+				AddServersToServerGroupResult();
+				explicit AddServersToServerGroupResult(const std::string &payload);
+				~AddServersToServerGroupResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getServerGroupId()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string serverGroupId_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_ADDSERVERSTOSERVERGROUPRESULT_H_

nlb/include/alibabacloud/nlb/model/AssociateAdditionalCertificatesWithListenerRequest.h

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

nlb/include/alibabacloud/nlb/model/AssociateAdditionalCertificatesWithListenerResult.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_NLB_MODEL_ASSOCIATEADDITIONALCERTIFICATESWITHLISTENERRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_ASSOCIATEADDITIONALCERTIFICATESWITHLISTENERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT AssociateAdditionalCertificatesWithListenerResult : public ServiceResult
+			{
+			public:
+
+
+				AssociateAdditionalCertificatesWithListenerResult();
+				explicit AssociateAdditionalCertificatesWithListenerResult(const std::string &payload);
+				~AssociateAdditionalCertificatesWithListenerResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_ASSOCIATEADDITIONALCERTIFICATESWITHLISTENERRESULT_H_

nlb/include/alibabacloud/nlb/model/AttachCommonBandwidthPackageToLoadBalancerRequest.h

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

nlb/include/alibabacloud/nlb/model/AttachCommonBandwidthPackageToLoadBalancerResult.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_NLB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT AttachCommonBandwidthPackageToLoadBalancerResult : public ServiceResult
+			{
+			public:
+
+
+				AttachCommonBandwidthPackageToLoadBalancerResult();
+				explicit AttachCommonBandwidthPackageToLoadBalancerResult(const std::string &payload);
+				~AttachCommonBandwidthPackageToLoadBalancerResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERRESULT_H_

nlb/include/alibabacloud/nlb/model/CancelShiftLoadBalancerZonesRequest.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_CANCELSHIFTLOADBALANCERZONESREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_CANCELSHIFTLOADBALANCERZONESREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT CancelShiftLoadBalancerZonesRequest : public RpcServiceRequest {
+public:
+	struct ZoneMappings {
+		std::string vSwitchId;
+		std::string zoneId;
+	};
+	CancelShiftLoadBalancerZonesRequest();
+	~CancelShiftLoadBalancerZonesRequest();
+	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::vector<ZoneMappings> getZoneMappings() const;
+	void setZoneMappings(const std::vector<ZoneMappings> &zoneMappings);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	bool dryRun_;
+	std::vector<ZoneMappings> zoneMappings_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_CANCELSHIFTLOADBALANCERZONESREQUEST_H_

nlb/include/alibabacloud/nlb/model/CancelShiftLoadBalancerZonesResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_CANCELSHIFTLOADBALANCERZONESRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_CANCELSHIFTLOADBALANCERZONESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT CancelShiftLoadBalancerZonesResult : public ServiceResult
+			{
+			public:
+
+
+				CancelShiftLoadBalancerZonesResult();
+				explicit CancelShiftLoadBalancerZonesResult(const std::string &payload);
+				~CancelShiftLoadBalancerZonesResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_CANCELSHIFTLOADBALANCERZONESRESULT_H_

nlb/include/alibabacloud/nlb/model/CreateListenerRequest.h

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_CREATELISTENERREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_CREATELISTENERREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT CreateListenerRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string key;
+		std::string value;
+	};
+	CreateListenerRequest();
+	~CreateListenerRequest();
+	std::vector<std::string> getCaCertificateIds() const;
+	void setCaCertificateIds(const std::vector<std::string> &caCertificateIds);
+	int getStartPort() const;
+	void setStartPort(int startPort);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getSecSensorEnabled() const;
+	void setSecSensorEnabled(bool secSensorEnabled);
+	std::string getAlpnPolicy() const;
+	void setAlpnPolicy(const std::string &alpnPolicy);
+	int getMss() const;
+	void setMss(int mss);
+	std::string getServerGroupId() const;
+	void setServerGroupId(const std::string &serverGroupId);
+	std::vector<std::string> getCertificateIds() const;
+	void setCertificateIds(const std::vector<std::string> &certificateIds);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	bool getAlpnEnabled() const;
+	void setAlpnEnabled(bool alpnEnabled);
+	int getEndPort() const;
+	void setEndPort(int endPort);
+	int getListenerPort() const;
+	void setListenerPort(int listenerPort);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	bool getProxyProtocolEnabled() const;
+	void setProxyProtocolEnabled(bool proxyProtocolEnabled);
+	int getCps() const;
+	void setCps(int cps);
+	std::string getListenerProtocol() const;
+	void setListenerProtocol(const std::string &listenerProtocol);
+	std::string getSecurityPolicyId() const;
+	void setSecurityPolicyId(const std::string &securityPolicyId);
+	int getIdleTimeout() const;
+	void setIdleTimeout(int idleTimeout);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+	std::string getListenerDescription() const;
+	void setListenerDescription(const std::string &listenerDescription);
+	bool getCaEnabled() const;
+	void setCaEnabled(bool caEnabled);
+
+private:
+	std::vector<std::string> caCertificateIds_;
+	int startPort_;
+	std::string clientToken_;
+	bool secSensorEnabled_;
+	std::string alpnPolicy_;
+	int mss_;
+	std::string serverGroupId_;
+	std::vector<std::string> certificateIds_;
+	std::string regionId_;
+	std::vector<Tag> tag_;
+	bool alpnEnabled_;
+	int endPort_;
+	int listenerPort_;
+	bool dryRun_;
+	bool proxyProtocolEnabled_;
+	int cps_;
+	std::string listenerProtocol_;
+	std::string securityPolicyId_;
+	int idleTimeout_;
+	std::string loadBalancerId_;
+	std::string listenerDescription_;
+	bool caEnabled_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_CREATELISTENERREQUEST_H_

nlb/include/alibabacloud/nlb/model/CreateListenerResult.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_NLB_MODEL_CREATELISTENERRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_CREATELISTENERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT CreateListenerResult : public ServiceResult
+			{
+			public:
+
+
+				CreateListenerResult();
+				explicit CreateListenerResult(const std::string &payload);
+				~CreateListenerResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+				std::string getListenerId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+				std::string listenerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_CREATELISTENERRESULT_H_

nlb/include/alibabacloud/nlb/model/CreateLoadBalancerRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_CREATELOADBALANCERREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_CREATELOADBALANCERREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT CreateLoadBalancerRequest : public RpcServiceRequest {
+public:
+	struct ModificationProtectionConfig {
+		std::string status;
+		std::string reason;
+	};
+	struct LoadBalancerBillingConfig {
+		std::string payType;
+	};
+	struct DeletionProtectionConfig {
+		bool enabled;
+		std::string reason;
+	};
+	struct Tag {
+		std::string key;
+		std::string value;
+	};
+	struct ZoneMappings {
+		std::string vSwitchId;
+		std::string zoneId;
+		std::string privateIPv4Address;
+		std::string allocationId;
+	};
+	CreateLoadBalancerRequest();
+	~CreateLoadBalancerRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	ModificationProtectionConfig getModificationProtectionConfig() const;
+	void setModificationProtectionConfig(const ModificationProtectionConfig &modificationProtectionConfig);
+	LoadBalancerBillingConfig getLoadBalancerBillingConfig() const;
+	void setLoadBalancerBillingConfig(const LoadBalancerBillingConfig &loadBalancerBillingConfig);
+	std::string getBizFlag() const;
+	void setBizFlag(const std::string &bizFlag);
+	DeletionProtectionConfig getDeletionProtectionConfig() const;
+	void setDeletionProtectionConfig(const DeletionProtectionConfig &deletionProtectionConfig);
+	std::string getAddressIpVersion() const;
+	void setAddressIpVersion(const std::string &addressIpVersion);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getLoadBalancerName() const;
+	void setLoadBalancerName(const std::string &loadBalancerName);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getAddressType() const;
+	void setAddressType(const std::string &addressType);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::string getBandwidthPackageId() const;
+	void setBandwidthPackageId(const std::string &bandwidthPackageId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::vector<ZoneMappings> getZoneMappings() const;
+	void setZoneMappings(const std::vector<ZoneMappings> &zoneMappings);
+	std::vector<std::string> getSecurityGroupIds() const;
+	void setSecurityGroupIds(const std::vector<std::string> &securityGroupIds);
+	std::string getLoadBalancerType() const;
+	void setLoadBalancerType(const std::string &loadBalancerType);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+
+private:
+	std::string clientToken_;
+	ModificationProtectionConfig modificationProtectionConfig_;
+	LoadBalancerBillingConfig loadBalancerBillingConfig_;
+	std::string bizFlag_;
+	DeletionProtectionConfig deletionProtectionConfig_;
+	std::string addressIpVersion_;
+	std::string resourceGroupId_;
+	std::string loadBalancerName_;
+	std::string regionId_;
+	std::string addressType_;
+	std::vector<Tag> tag_;
+	std::string bandwidthPackageId_;
+	bool dryRun_;
+	std::vector<ZoneMappings> zoneMappings_;
+	std::vector<std::string> securityGroupIds_;
+	std::string loadBalancerType_;
+	std::string vpcId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_CREATELOADBALANCERREQUEST_H_

nlb/include/alibabacloud/nlb/model/CreateLoadBalancerResult.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_CREATELOADBALANCERRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_CREATELOADBALANCERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT CreateLoadBalancerResult : public ServiceResult
+			{
+			public:
+
+
+				CreateLoadBalancerResult();
+				explicit CreateLoadBalancerResult(const std::string &payload);
+				~CreateLoadBalancerResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getLoadbalancerId()const;
+				long getOrderId()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string loadbalancerId_;
+				long orderId_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_CREATELOADBALANCERRESULT_H_

nlb/include/alibabacloud/nlb/model/CreateSecurityPolicyRequest.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_CREATESECURITYPOLICYREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_CREATESECURITYPOLICYREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT CreateSecurityPolicyRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string key;
+		std::string value;
+	};
+	CreateSecurityPolicyRequest();
+	~CreateSecurityPolicyRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<std::string> getCiphers() const;
+	void setCiphers(const std::vector<std::string> &ciphers);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::vector<std::string> getTlsVersions() const;
+	void setTlsVersions(const std::vector<std::string> &tlsVersions);
+	std::string getSecurityPolicyName() const;
+	void setSecurityPolicyName(const std::string &securityPolicyName);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::string resourceGroupId_;
+	std::string regionId_;
+	std::vector<std::string> ciphers_;
+	std::vector<Tag> tag_;
+	std::vector<std::string> tlsVersions_;
+	std::string securityPolicyName_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_CREATESECURITYPOLICYREQUEST_H_

nlb/include/alibabacloud/nlb/model/CreateSecurityPolicyResult.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_NLB_MODEL_CREATESECURITYPOLICYRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_CREATESECURITYPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT CreateSecurityPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				CreateSecurityPolicyResult();
+				explicit CreateSecurityPolicyResult(const std::string &payload);
+				~CreateSecurityPolicyResult();
+				std::string getSecurityPolicyId()const;
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string securityPolicyId_;
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_CREATESECURITYPOLICYRESULT_H_

nlb/include/alibabacloud/nlb/model/CreateServerGroupRequest.h

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_CREATESERVERGROUPREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_CREATESERVERGROUPREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT CreateServerGroupRequest : public RpcServiceRequest {
+public:
+	struct HealthCheckConfig {
+		bool healthCheckEnabled;
+		std::string healthCheckType;
+		int healthCheckConnectPort;
+		int healthyThreshold;
+		int unhealthyThreshold;
+		int healthCheckConnectTimeout;
+		int healthCheckInterval;
+		std::string healthCheckDomain;
+		std::string healthCheckUrl;
+		std::string string;
+		std::vector<std::string> healthCheckHttpCode;
+		std::string httpCheckMethod;
+	};
+	struct Tag {
+		std::string key;
+		std::string value;
+	};
+	CreateServerGroupRequest();
+	~CreateServerGroupRequest();
+	std::string getQuicVersion() const;
+	void setQuicVersion(const std::string &quicVersion);
+	std::string getServerGroupName() const;
+	void setServerGroupName(const std::string &serverGroupName);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getPreserveClientIpEnabled() const;
+	void setPreserveClientIpEnabled(bool preserveClientIpEnabled);
+	HealthCheckConfig getHealthCheckConfig() const;
+	void setHealthCheckConfig(const HealthCheckConfig &healthCheckConfig);
+	std::string getAddressIPVersion() const;
+	void setAddressIPVersion(const std::string &addressIPVersion);
+	std::string getScheduler() const;
+	void setScheduler(const std::string &scheduler);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getProtocol() const;
+	void setProtocol(const std::string &protocol);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getPersistenceEnabled() const;
+	void setPersistenceEnabled(bool persistenceEnabled);
+	int getPersistenceTimeout() const;
+	void setPersistenceTimeout(int persistenceTimeout);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	bool getConnectionDrainEnabled() const;
+	void setConnectionDrainEnabled(bool connectionDrainEnabled);
+	int getConnectionDrainTimeout() const;
+	void setConnectionDrainTimeout(int connectionDrainTimeout);
+	bool getAnyPortEnabled() const;
+	void setAnyPortEnabled(bool anyPortEnabled);
+	std::string getServerGroupType() const;
+	void setServerGroupType(const std::string &serverGroupType);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+
+private:
+	std::string quicVersion_;
+	std::string serverGroupName_;
+	std::string clientToken_;
+	bool preserveClientIpEnabled_;
+	HealthCheckConfig healthCheckConfig_;
+	std::string addressIPVersion_;
+	std::string scheduler_;
+	std::string resourceGroupId_;
+	std::string protocol_;
+	std::string regionId_;
+	bool persistenceEnabled_;
+	int persistenceTimeout_;
+	std::vector<Tag> tag_;
+	bool dryRun_;
+	bool connectionDrainEnabled_;
+	int connectionDrainTimeout_;
+	bool anyPortEnabled_;
+	std::string serverGroupType_;
+	std::string vpcId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_CREATESERVERGROUPREQUEST_H_

nlb/include/alibabacloud/nlb/model/CreateServerGroupResult.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_NLB_MODEL_CREATESERVERGROUPRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_CREATESERVERGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT CreateServerGroupResult : public ServiceResult
+			{
+			public:
+
+
+				CreateServerGroupResult();
+				explicit CreateServerGroupResult(const std::string &payload);
+				~CreateServerGroupResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getServerGroupId()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string serverGroupId_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_CREATESERVERGROUPRESULT_H_

nlb/include/alibabacloud/nlb/model/DeleteListenerRequest.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_NLB_MODEL_DELETELISTENERREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_DELETELISTENERREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT DeleteListenerRequest : public RpcServiceRequest {
+public:
+	DeleteListenerRequest();
+	~DeleteListenerRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::string listenerId_;
+	std::string regionId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_DELETELISTENERREQUEST_H_

nlb/include/alibabacloud/nlb/model/DeleteListenerResult.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_NLB_MODEL_DELETELISTENERRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_DELETELISTENERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT DeleteListenerResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteListenerResult();
+				explicit DeleteListenerResult(const std::string &payload);
+				~DeleteListenerResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_DELETELISTENERRESULT_H_

nlb/include/alibabacloud/nlb/model/DeleteLoadBalancerRequest.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_NLB_MODEL_DELETELOADBALANCERREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_DELETELOADBALANCERREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT DeleteLoadBalancerRequest : public RpcServiceRequest {
+public:
+	DeleteLoadBalancerRequest();
+	~DeleteLoadBalancerRequest();
+	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 getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	bool dryRun_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_DELETELOADBALANCERREQUEST_H_

nlb/include/alibabacloud/nlb/model/DeleteLoadBalancerResult.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_NLB_MODEL_DELETELOADBALANCERRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_DELETELOADBALANCERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT DeleteLoadBalancerResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteLoadBalancerResult();
+				explicit DeleteLoadBalancerResult(const std::string &payload);
+				~DeleteLoadBalancerResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_DELETELOADBALANCERRESULT_H_

nlb/include/alibabacloud/nlb/model/DeleteSecurityPolicyRequest.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_NLB_MODEL_DELETESECURITYPOLICYREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_DELETESECURITYPOLICYREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT DeleteSecurityPolicyRequest : public RpcServiceRequest {
+public:
+	DeleteSecurityPolicyRequest();
+	~DeleteSecurityPolicyRequest();
+	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 getSecurityPolicyId() const;
+	void setSecurityPolicyId(const std::string &securityPolicyId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	bool dryRun_;
+	std::string securityPolicyId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_DELETESECURITYPOLICYREQUEST_H_

nlb/include/alibabacloud/nlb/model/DeleteSecurityPolicyResult.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_NLB_MODEL_DELETESECURITYPOLICYRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_DELETESECURITYPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT DeleteSecurityPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteSecurityPolicyResult();
+				explicit DeleteSecurityPolicyResult(const std::string &payload);
+				~DeleteSecurityPolicyResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_DELETESECURITYPOLICYRESULT_H_

nlb/include/alibabacloud/nlb/model/DeleteServerGroupRequest.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_NLB_MODEL_DELETESERVERGROUPREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_DELETESERVERGROUPREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT DeleteServerGroupRequest : public RpcServiceRequest {
+public:
+	DeleteServerGroupRequest();
+	~DeleteServerGroupRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getServerGroupId() const;
+	void setServerGroupId(const std::string &serverGroupId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::string serverGroupId_;
+	std::string regionId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_DELETESERVERGROUPREQUEST_H_

nlb/include/alibabacloud/nlb/model/DeleteServerGroupResult.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_NLB_MODEL_DELETESERVERGROUPRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_DELETESERVERGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT DeleteServerGroupResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteServerGroupResult();
+				explicit DeleteServerGroupResult(const std::string &payload);
+				~DeleteServerGroupResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getServerGroupId()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string serverGroupId_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_DELETESERVERGROUPRESULT_H_

nlb/include/alibabacloud/nlb/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_NLB_MODEL_DESCRIBEREGIONSREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_DESCRIBEREGIONSREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT DescribeRegionsRequest : public RpcServiceRequest {
+public:
+	DescribeRegionsRequest();
+	~DescribeRegionsRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getServiceCode() const;
+	void setServiceCode(const std::string &serviceCode);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::string clientToken_;
+	std::string serviceCode_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_DESCRIBEREGIONSREQUEST_H_

nlb/include/alibabacloud/nlb/model/DescribeRegionsResult.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_NLB_MODEL_DESCRIBEREGIONSRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_DESCRIBEREGIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_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::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::vector<Region> getRegions()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::vector<Region> regions_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_DESCRIBEREGIONSRESULT_H_

nlb/include/alibabacloud/nlb/model/DescribeZonesRequest.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_NLB_MODEL_DESCRIBEZONESREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_DESCRIBEZONESREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT DescribeZonesRequest : public RpcServiceRequest {
+public:
+	DescribeZonesRequest();
+	~DescribeZonesRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getServiceCode() const;
+	void setServiceCode(const std::string &serviceCode);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	std::string serviceCode_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_DESCRIBEZONESREQUEST_H_

nlb/include/alibabacloud/nlb/model/DescribeZonesResult.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_DESCRIBEZONESRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_DESCRIBEZONESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT DescribeZonesResult : public ServiceResult
+			{
+			public:
+				struct Zone
+				{
+					std::string zoneId;
+					std::string localName;
+				};
+
+
+				DescribeZonesResult();
+				explicit DescribeZonesResult(const std::string &payload);
+				~DescribeZonesResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::vector<Zone> getZones()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::vector<Zone> zones_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_DESCRIBEZONESRESULT_H_

nlb/include/alibabacloud/nlb/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.h

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

nlb/include/alibabacloud/nlb/model/DetachCommonBandwidthPackageFromLoadBalancerResult.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_NLB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT DetachCommonBandwidthPackageFromLoadBalancerResult : public ServiceResult
+			{
+			public:
+
+
+				DetachCommonBandwidthPackageFromLoadBalancerResult();
+				explicit DetachCommonBandwidthPackageFromLoadBalancerResult(const std::string &payload);
+				~DetachCommonBandwidthPackageFromLoadBalancerResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERRESULT_H_

nlb/include/alibabacloud/nlb/model/DisableLoadBalancerIpv6InternetRequest.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_NLB_MODEL_DISABLELOADBALANCERIPV6INTERNETREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_DISABLELOADBALANCERIPV6INTERNETREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT DisableLoadBalancerIpv6InternetRequest : public RpcServiceRequest {
+public:
+	DisableLoadBalancerIpv6InternetRequest();
+	~DisableLoadBalancerIpv6InternetRequest();
+	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 getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	bool dryRun_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_DISABLELOADBALANCERIPV6INTERNETREQUEST_H_

nlb/include/alibabacloud/nlb/model/DisableLoadBalancerIpv6InternetResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_DISABLELOADBALANCERIPV6INTERNETRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_DISABLELOADBALANCERIPV6INTERNETRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT DisableLoadBalancerIpv6InternetResult : public ServiceResult
+			{
+			public:
+
+
+				DisableLoadBalancerIpv6InternetResult();
+				explicit DisableLoadBalancerIpv6InternetResult(const std::string &payload);
+				~DisableLoadBalancerIpv6InternetResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_DISABLELOADBALANCERIPV6INTERNETRESULT_H_

nlb/include/alibabacloud/nlb/model/DisassociateAdditionalCertificatesWithListenerRequest.h

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

nlb/include/alibabacloud/nlb/model/DisassociateAdditionalCertificatesWithListenerResult.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_NLB_MODEL_DISASSOCIATEADDITIONALCERTIFICATESWITHLISTENERRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_DISASSOCIATEADDITIONALCERTIFICATESWITHLISTENERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT DisassociateAdditionalCertificatesWithListenerResult : public ServiceResult
+			{
+			public:
+
+
+				DisassociateAdditionalCertificatesWithListenerResult();
+				explicit DisassociateAdditionalCertificatesWithListenerResult(const std::string &payload);
+				~DisassociateAdditionalCertificatesWithListenerResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_DISASSOCIATEADDITIONALCERTIFICATESWITHLISTENERRESULT_H_

nlb/include/alibabacloud/nlb/model/EnableLoadBalancerIpv6InternetRequest.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_NLB_MODEL_ENABLELOADBALANCERIPV6INTERNETREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_ENABLELOADBALANCERIPV6INTERNETREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT EnableLoadBalancerIpv6InternetRequest : public RpcServiceRequest {
+public:
+	EnableLoadBalancerIpv6InternetRequest();
+	~EnableLoadBalancerIpv6InternetRequest();
+	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 getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	bool dryRun_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_ENABLELOADBALANCERIPV6INTERNETREQUEST_H_

nlb/include/alibabacloud/nlb/model/EnableLoadBalancerIpv6InternetResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_ENABLELOADBALANCERIPV6INTERNETRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_ENABLELOADBALANCERIPV6INTERNETRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT EnableLoadBalancerIpv6InternetResult : public ServiceResult
+			{
+			public:
+
+
+				EnableLoadBalancerIpv6InternetResult();
+				explicit EnableLoadBalancerIpv6InternetResult(const std::string &payload);
+				~EnableLoadBalancerIpv6InternetResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_ENABLELOADBALANCERIPV6INTERNETRESULT_H_

nlb/include/alibabacloud/nlb/model/GetJobStatusRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_GETJOBSTATUSREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_GETJOBSTATUSREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT GetJobStatusRequest : public RpcServiceRequest {
+public:
+	GetJobStatusRequest();
+	~GetJobStatusRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getJobId() const;
+	void setJobId(const std::string &jobId);
+
+private:
+	std::string clientToken_;
+	std::string jobId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_GETJOBSTATUSREQUEST_H_

nlb/include/alibabacloud/nlb/model/GetJobStatusResult.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_NLB_MODEL_GETJOBSTATUSRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_GETJOBSTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT GetJobStatusResult : public ServiceResult
+			{
+			public:
+
+
+				GetJobStatusResult();
+				explicit GetJobStatusResult(const std::string &payload);
+				~GetJobStatusResult();
+				std::string getStatus()const;
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_GETJOBSTATUSRESULT_H_

nlb/include/alibabacloud/nlb/model/GetListenerAttributeRequest.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_NLB_MODEL_GETLISTENERATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_GETLISTENERATTRIBUTEREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT GetListenerAttributeRequest : public RpcServiceRequest {
+public:
+	GetListenerAttributeRequest();
+	~GetListenerAttributeRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::string listenerId_;
+	std::string regionId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_GETLISTENERATTRIBUTEREQUEST_H_

nlb/include/alibabacloud/nlb/model/GetListenerAttributeResult.h

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_GETLISTENERATTRIBUTERESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_GETLISTENERATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT GetListenerAttributeResult : public ServiceResult
+			{
+			public:
+				struct Tag
+				{
+					std::string tagKey;
+					std::string tagValue;
+				};
+
+
+				GetListenerAttributeResult();
+				explicit GetListenerAttributeResult(const std::string &payload);
+				~GetListenerAttributeResult();
+				std::string getMessage()const;
+				int getCps()const;
+				int getIdleTimeout()const;
+				std::string getLoadBalancerId()const;
+				std::string getDynamicMessage()const;
+				std::string getListenerProtocol()const;
+				bool getSuccess()const;
+				std::string getSecurityPolicyId()const;
+				std::string getListenerStatus()const;
+				std::string getListenerDescription()const;
+				std::string getAlpnPolicy()const;
+				std::vector<std::string> getCaCertificateIds()const;
+				std::vector<std::string> getCertificateIds()const;
+				int getHttpStatusCode()const;
+				bool getSecSensorEnabled()const;
+				std::string getDynamicCode()const;
+				std::vector<Tag> getTags()const;
+				bool getCaEnabled()const;
+				int getListenerPort()const;
+				std::string getStartPort()const;
+				std::string getServerGroupId()const;
+				int getMss()const;
+				std::string getCode()const;
+				std::string getEndPort()const;
+				bool getProxyProtocolEnabled()const;
+				std::string getRegionId()const;
+				std::string getListenerId()const;
+				bool getAlpnEnabled()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int cps_;
+				int idleTimeout_;
+				std::string loadBalancerId_;
+				std::string dynamicMessage_;
+				std::string listenerProtocol_;
+				bool success_;
+				std::string securityPolicyId_;
+				std::string listenerStatus_;
+				std::string listenerDescription_;
+				std::string alpnPolicy_;
+				std::vector<std::string> caCertificateIds_;
+				std::vector<std::string> certificateIds_;
+				int httpStatusCode_;
+				bool secSensorEnabled_;
+				std::string dynamicCode_;
+				std::vector<Tag> tags_;
+				bool caEnabled_;
+				int listenerPort_;
+				std::string startPort_;
+				std::string serverGroupId_;
+				int mss_;
+				std::string code_;
+				std::string endPort_;
+				bool proxyProtocolEnabled_;
+				std::string regionId_;
+				std::string listenerId_;
+				bool alpnEnabled_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_GETLISTENERATTRIBUTERESULT_H_

nlb/include/alibabacloud/nlb/model/GetListenerHealthStatusRequest.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_NLB_MODEL_GETLISTENERHEALTHSTATUSREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_GETLISTENERHEALTHSTATUSREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT GetListenerHealthStatusRequest : public RpcServiceRequest {
+public:
+	GetListenerHealthStatusRequest();
+	~GetListenerHealthStatusRequest();
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+
+private:
+	std::string listenerId_;
+	std::string nextToken_;
+	std::string regionId_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_GETLISTENERHEALTHSTATUSREQUEST_H_

nlb/include/alibabacloud/nlb/model/GetListenerHealthStatusResult.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_GETLISTENERHEALTHSTATUSRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_GETLISTENERHEALTHSTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT GetListenerHealthStatusResult : public ServiceResult
+			{
+			public:
+				struct ListenerHealthStatusItem
+				{
+					struct ServerGroupInfo
+					{
+						struct AbnormalServer
+						{
+							struct Reason
+							{
+								std::string reasonCode;
+							};
+							std::string status;
+							std::string serverId;
+							int port;
+							std::string serverIp;
+							Reason reason;
+						};
+						std::vector<ServerGroupInfo::AbnormalServer> nonNormalServers;
+						std::string serverGroupId;
+						bool heathCheckEnabled;
+					};
+					int listenerPort;
+					std::vector<ListenerHealthStatusItem::ServerGroupInfo> serverGroupInfos;
+					std::string listenerProtocol;
+					std::string listenerId;
+				};
+
+
+				GetListenerHealthStatusResult();
+				explicit GetListenerHealthStatusResult(const std::string &payload);
+				~GetListenerHealthStatusResult();
+				std::vector<ListenerHealthStatusItem> getListenerHealthStatus()const;
+				int getTotalCount()const;
+				std::string getMessage()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<ListenerHealthStatusItem> listenerHealthStatus_;
+				int totalCount_;
+				std::string message_;
+				std::string nextToken_;
+				int maxResults_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_GETLISTENERHEALTHSTATUSRESULT_H_

nlb/include/alibabacloud/nlb/model/GetLoadBalancerAttributeRequest.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_NLB_MODEL_GETLOADBALANCERATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_GETLOADBALANCERATTRIBUTEREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT GetLoadBalancerAttributeRequest : public RpcServiceRequest {
+public:
+	GetLoadBalancerAttributeRequest();
+	~GetLoadBalancerAttributeRequest();
+	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 getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	bool dryRun_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_GETLOADBALANCERATTRIBUTEREQUEST_H_

nlb/include/alibabacloud/nlb/model/GetLoadBalancerAttributeResult.h

@@ -0,0 +1,159 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_GETLOADBALANCERATTRIBUTERESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_GETLOADBALANCERATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT GetLoadBalancerAttributeResult : public ServiceResult
+			{
+			public:
+				struct LoadBalancerBillingConfig
+				{
+					int internetBandwidth;
+					std::string payType;
+					std::string internetChargeType;
+				};
+				struct DeletionProtectionConfig
+				{
+					bool enabled;
+					std::string enabledTime;
+					std::string reason;
+				};
+				struct ModificationProtectionConfig
+				{
+					std::string status;
+					std::string enabledTime;
+					std::string reason;
+				};
+				struct OperationLock
+				{
+					std::string lockReason;
+					std::string lockType;
+				};
+				struct ZoneMapping
+				{
+					struct LoadBalancerAddress
+					{
+						std::string eniId;
+						std::string publicIPv4Address;
+						std::string allocationId;
+						std::string privateIPv4HcStatus;
+						std::string privateIPv6HcStatus;
+						std::string ipv6Address;
+						std::string privateIPv4Address;
+					};
+					std::string status;
+					std::string zoneId;
+					std::string vSwitchId;
+					std::string eipType;
+					std::vector<ZoneMapping::LoadBalancerAddress> loadBalancerAddresses;
+				};
+				struct Tag
+				{
+					std::string tagKey;
+					std::string tagValue;
+				};
+
+
+				GetLoadBalancerAttributeResult();
+				explicit GetLoadBalancerAttributeResult(const std::string &payload);
+				~GetLoadBalancerAttributeResult();
+				std::string getAddressIpVersion()const;
+				std::string getMessage()const;
+				std::string getResourceGroupId()const;
+				int getCps()const;
+				std::string getLoadBalancerId()const;
+				std::string getDynamicMessage()const;
+				std::vector<ZoneMapping> getZoneMappings()const;
+				std::string getDNSName()const;
+				bool getSuccess()const;
+				std::string getIpv6AddressType()const;
+				bool getCrossZoneEnabled()const;
+				std::string getLoadBalancerType()const;
+				long getCapacityUnitCount()const;
+				DeletionProtectionConfig getDeletionProtectionConfig()const;
+				std::string getSysSecurityGroupId()const;
+				int getHttpStatusCode()const;
+				std::string getBandwidthPackageId()const;
+				std::string getDynamicCode()const;
+				std::vector<Tag> getTags()const;
+				LoadBalancerBillingConfig getLoadBalancerBillingConfig()const;
+				std::string getCreateTime()const;
+				ModificationProtectionConfig getModificationProtectionConfig()const;
+				std::vector<std::string> getSecurityGroupIds()const;
+				std::string getCode()const;
+				std::vector<OperationLock> getOperationLocks()const;
+				std::string getLoadBalancerName()const;
+				std::string getVpcId()const;
+				bool getTrafficAffinityEnabled()const;
+				std::string getRegionId()const;
+				std::string getAddressType()const;
+				std::string getLoadBalancerStatus()const;
+				std::string getLoadBalancerBusinessStatus()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string addressIpVersion_;
+				std::string message_;
+				std::string resourceGroupId_;
+				int cps_;
+				std::string loadBalancerId_;
+				std::string dynamicMessage_;
+				std::vector<ZoneMapping> zoneMappings_;
+				std::string dNSName_;
+				bool success_;
+				std::string ipv6AddressType_;
+				bool crossZoneEnabled_;
+				std::string loadBalancerType_;
+				long capacityUnitCount_;
+				DeletionProtectionConfig deletionProtectionConfig_;
+				std::string sysSecurityGroupId_;
+				int httpStatusCode_;
+				std::string bandwidthPackageId_;
+				std::string dynamicCode_;
+				std::vector<Tag> tags_;
+				LoadBalancerBillingConfig loadBalancerBillingConfig_;
+				std::string createTime_;
+				ModificationProtectionConfig modificationProtectionConfig_;
+				std::vector<std::string> securityGroupIds_;
+				std::string code_;
+				std::vector<OperationLock> operationLocks_;
+				std::string loadBalancerName_;
+				std::string vpcId_;
+				bool trafficAffinityEnabled_;
+				std::string regionId_;
+				std::string addressType_;
+				std::string loadBalancerStatus_;
+				std::string loadBalancerBusinessStatus_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_GETLOADBALANCERATTRIBUTERESULT_H_

nlb/include/alibabacloud/nlb/model/ListListenerCertificatesRequest.h

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

nlb/include/alibabacloud/nlb/model/ListListenerCertificatesResult.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_LISTLISTENERCERTIFICATESRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_LISTLISTENERCERTIFICATESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT ListListenerCertificatesResult : public ServiceResult
+			{
+			public:
+				struct Certificate
+				{
+					bool isDefault;
+					std::string status;
+					std::string certificateType;
+					std::string certificateId;
+				};
+
+
+				ListListenerCertificatesResult();
+				explicit ListListenerCertificatesResult(const std::string &payload);
+				~ListListenerCertificatesResult();
+				int getTotalCount()const;
+				std::string getMessage()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				std::vector<Certificate> getCertificates()const;
+				std::vector<std::string> getCertificateIds()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string message_;
+				std::string nextToken_;
+				int maxResults_;
+				std::vector<Certificate> certificates_;
+				std::vector<std::string> certificateIds_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_LISTLISTENERCERTIFICATESRESULT_H_

nlb/include/alibabacloud/nlb/model/ListListenersRequest.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_LISTLISTENERSREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_LISTLISTENERSREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT ListListenersRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string key;
+		std::string value;
+	};
+	ListListenersRequest();
+	~ListListenersRequest();
+	std::vector<std::string> getLoadBalancerIds() const;
+	void setLoadBalancerIds(const std::vector<std::string> &loadBalancerIds);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::string getListenerProtocol() const;
+	void setListenerProtocol(const std::string &listenerProtocol);
+	std::vector<std::string> getListenerIds() const;
+	void setListenerIds(const std::vector<std::string> &listenerIds);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+
+private:
+	std::vector<std::string> loadBalancerIds_;
+	std::string nextToken_;
+	std::string regionId_;
+	std::vector<Tag> tag_;
+	std::string listenerProtocol_;
+	std::vector<std::string> listenerIds_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_LISTLISTENERSREQUEST_H_

nlb/include/alibabacloud/nlb/model/ListListenersResult.h

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_LISTLISTENERSRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_LISTLISTENERSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT ListListenersResult : public ServiceResult
+			{
+			public:
+				struct ListenerInfo
+				{
+					struct TagModels
+					{
+						std::string value;
+						std::string key;
+					};
+					bool caEnabled;
+					int listenerPort;
+					std::string startPort;
+					int cps;
+					std::string serverGroupId;
+					int idleTimeout;
+					std::string loadBalancerId;
+					std::string listenerProtocol;
+					int mss;
+					std::string securityPolicyId;
+					std::string listenerStatus;
+					std::string listenerDescription;
+					std::string alpnPolicy;
+					std::vector<std::string> caCertificateIds;
+					std::string endPort;
+					bool proxyProtocolEnabled;
+					std::vector<std::string> certificateIds;
+					bool secSensorEnabled;
+					std::string regionId;
+					std::vector<ListenerInfo::TagModels> tags;
+					std::string listenerId;
+					bool alpnEnabled;
+				};
+
+
+				ListListenersResult();
+				explicit ListListenersResult(const std::string &payload);
+				~ListListenersResult();
+				std::vector<ListenerInfo> getListeners()const;
+				int getTotalCount()const;
+				std::string getMessage()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<ListenerInfo> listeners_;
+				int totalCount_;
+				std::string message_;
+				std::string nextToken_;
+				int maxResults_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_LISTLISTENERSRESULT_H_

nlb/include/alibabacloud/nlb/model/ListLoadBalancersRequest.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_LISTLOADBALANCERSREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_LISTLOADBALANCERSREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT ListLoadBalancersRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string key;
+		std::string value;
+	};
+	ListLoadBalancersRequest();
+	~ListLoadBalancersRequest();
+	std::vector<std::string> getLoadBalancerNames() const;
+	void setLoadBalancerNames(const std::vector<std::string> &loadBalancerNames);
+	std::vector<std::string> getLoadBalancerIds() const;
+	void setLoadBalancerIds(const std::vector<std::string> &loadBalancerIds);
+	std::string getAddressIpVersion() const;
+	void setAddressIpVersion(const std::string &addressIpVersion);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDNSName() const;
+	void setDNSName(const std::string &dNSName);
+	std::string getAddressType() const;
+	void setAddressType(const std::string &addressType);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::vector<std::string> getVpcIds() const;
+	void setVpcIds(const std::vector<std::string> &vpcIds);
+	std::string getAddress() const;
+	void setAddress(const std::string &address);
+	std::string getLoadBalancerBusinessStatus() const;
+	void setLoadBalancerBusinessStatus(const std::string &loadBalancerBusinessStatus);
+	std::string getLoadBalancerStatus() const;
+	void setLoadBalancerStatus(const std::string &loadBalancerStatus);
+	std::string getLoadBalancerType() const;
+	void setLoadBalancerType(const std::string &loadBalancerType);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+	std::string getIpv6AddressType() const;
+	void setIpv6AddressType(const std::string &ipv6AddressType);
+
+private:
+	std::vector<std::string> loadBalancerNames_;
+	std::vector<std::string> loadBalancerIds_;
+	std::string addressIpVersion_;
+	std::string resourceGroupId_;
+	std::string nextToken_;
+	std::string regionId_;
+	std::string dNSName_;
+	std::string addressType_;
+	std::vector<Tag> tag_;
+	std::vector<std::string> vpcIds_;
+	std::string address_;
+	std::string loadBalancerBusinessStatus_;
+	std::string loadBalancerStatus_;
+	std::string loadBalancerType_;
+	std::string zoneId_;
+	int maxResults_;
+	std::string ipv6AddressType_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_LISTLOADBALANCERSREQUEST_H_

nlb/include/alibabacloud/nlb/model/ListLoadBalancersResult.h

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_LISTLOADBALANCERSRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_LISTLOADBALANCERSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT ListLoadBalancersResult : public ServiceResult
+			{
+			public:
+				struct LoadbalancerInfo
+				{
+					struct LoadBalancerBillingConfig
+					{
+						int internetBandwidth;
+						std::string payType;
+						std::string internetChargeType;
+					};
+					struct DeletionProtectionConfig
+					{
+						bool enabled;
+						std::string enabledTime;
+						std::string reason;
+					};
+					struct ModificationProtectionConfig
+					{
+						std::string status;
+						std::string enabledTime;
+						std::string reason;
+					};
+					struct OperationLock
+					{
+						std::string lockReason;
+						std::string lockType;
+					};
+					struct ZoneMapping
+					{
+						struct LoadBalancerAddress
+						{
+							std::string eniId;
+							std::string publicIPv4Address;
+							std::string allocationId;
+							std::string privateIPv4HcStatus;
+							std::string privateIPv6HcStatus;
+							std::string ipv6Address;
+							std::string privateIPv4Address;
+						};
+						std::string status;
+						std::string zoneId;
+						std::string vSwitchId;
+						std::string eipType;
+						std::vector<ZoneMapping::LoadBalancerAddress> loadBalancerAddresses;
+					};
+					struct TagModels
+					{
+						std::string value;
+						std::string key;
+					};
+					std::string addressIpVersion;
+					std::string resourceGroupId;
+					std::string loadBalancerId;
+					std::vector<LoadbalancerInfo::ZoneMapping> zoneMappings;
+					std::string dNSName;
+					std::string ipv6AddressType;
+					bool crossZoneEnabled;
+					std::string loadBalancerType;
+					long capacityUnitCount;
+					DeletionProtectionConfig deletionProtectionConfig;
+					std::string sysSecurityGroupId;
+					std::string bandwidthPackageId;
+					std::vector<LoadbalancerInfo::TagModels> tags;
+					LoadBalancerBillingConfig loadBalancerBillingConfig;
+					std::string createTime;
+					ModificationProtectionConfig modificationProtectionConfig;
+					std::vector<std::string> securityGroupIds;
+					std::vector<LoadbalancerInfo::OperationLock> operationLocks;
+					std::string loadBalancerName;
+					std::string vpcId;
+					bool trafficAffinityEnabled;
+					std::string regionId;
+					std::string addressType;
+					std::string loadBalancerStatus;
+					std::string loadBalancerBusinessStatus;
+					long aliUid;
+				};
+
+
+				ListLoadBalancersResult();
+				explicit ListLoadBalancersResult(const std::string &payload);
+				~ListLoadBalancersResult();
+				int getTotalCount()const;
+				std::string getMessage()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				int getHttpStatusCode()const;
+				std::vector<LoadbalancerInfo> getLoadBalancers()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string message_;
+				std::string nextToken_;
+				int maxResults_;
+				int httpStatusCode_;
+				std::vector<LoadbalancerInfo> loadBalancers_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_LISTLOADBALANCERSRESULT_H_

nlb/include/alibabacloud/nlb/model/ListSecurityPolicyRequest.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_LISTSECURITYPOLICYREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_LISTSECURITYPOLICYREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT ListSecurityPolicyRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string key;
+		std::string value;
+	};
+	ListSecurityPolicyRequest();
+	~ListSecurityPolicyRequest();
+	std::vector<std::string> getSecurityPolicyNames() const;
+	void setSecurityPolicyNames(const std::vector<std::string> &securityPolicyNames);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::vector<std::string> getSecurityPolicyIds() const;
+	void setSecurityPolicyIds(const std::vector<std::string> &securityPolicyIds);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+
+private:
+	std::vector<std::string> securityPolicyNames_;
+	std::string resourceGroupId_;
+	std::string nextToken_;
+	std::string regionId_;
+	std::vector<Tag> tag_;
+	std::vector<std::string> securityPolicyIds_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_LISTSECURITYPOLICYREQUEST_H_

nlb/include/alibabacloud/nlb/model/ListSecurityPolicyResult.h

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_LISTSECURITYPOLICYRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_LISTSECURITYPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT ListSecurityPolicyResult : public ServiceResult
+			{
+			public:
+				struct SecurityPolicie
+				{
+					struct Tag
+					{
+						std::string value;
+						std::string key;
+					};
+					struct RelatedListener
+					{
+						long listenerPort;
+						std::string loadBalancerId;
+						std::string listenerProtocol;
+						std::string listenerId;
+					};
+					std::string tlsVersion;
+					std::string ciphers;
+					std::string securityPolicyId;
+					std::string resourceGroupId;
+					std::string securityPolicyStatus;
+					std::string securityPolicyName;
+					std::string regionId;
+					std::vector<SecurityPolicie::RelatedListener> relatedListeners;
+					std::vector<SecurityPolicie::Tag> tags;
+				};
+
+
+				ListSecurityPolicyResult();
+				explicit ListSecurityPolicyResult(const std::string &payload);
+				~ListSecurityPolicyResult();
+				int getTotalCount()const;
+				std::string getMessage()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				std::vector<SecurityPolicie> getSecurityPolicies()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string message_;
+				std::string nextToken_;
+				int maxResults_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				std::vector<SecurityPolicie> securityPolicies_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_LISTSECURITYPOLICYRESULT_H_

nlb/include/alibabacloud/nlb/model/ListServerGroupServersRequest.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_NLB_MODEL_LISTSERVERGROUPSERVERSREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_LISTSERVERGROUPSERVERSREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT ListServerGroupServersRequest : public RpcServiceRequest {
+public:
+	ListServerGroupServersRequest();
+	~ListServerGroupServersRequest();
+	std::string getServerGroupId() const;
+	void setServerGroupId(const std::string &serverGroupId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<std::string> getServerIds() const;
+	void setServerIds(const std::vector<std::string> &serverIds);
+	std::vector<std::string> getServerIps() const;
+	void setServerIps(const std::vector<std::string> &serverIps);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+
+private:
+	std::string serverGroupId_;
+	std::string nextToken_;
+	std::string regionId_;
+	std::vector<std::string> serverIds_;
+	std::vector<std::string> serverIps_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_LISTSERVERGROUPSERVERSREQUEST_H_

nlb/include/alibabacloud/nlb/model/ListServerGroupServersResult.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_NLB_MODEL_LISTSERVERGROUPSERVERSRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_LISTSERVERGROUPSERVERSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT ListServerGroupServersResult : public ServiceResult
+			{
+			public:
+				struct Server
+				{
+					std::string status;
+					std::string serverType;
+					std::string serverId;
+					std::string description;
+					std::string zoneId;
+					std::string serverIp;
+					int port;
+					std::string serverGroupId;
+					int weight;
+				};
+
+
+				ListServerGroupServersResult();
+				explicit ListServerGroupServersResult(const std::string &payload);
+				~ListServerGroupServersResult();
+				int getTotalCount()const;
+				std::string getMessage()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::vector<Server> getServers()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string message_;
+				std::string nextToken_;
+				int maxResults_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::vector<Server> servers_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_LISTSERVERGROUPSERVERSRESULT_H_

nlb/include/alibabacloud/nlb/model/ListServerGroupsRequest.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_LISTSERVERGROUPSREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_LISTSERVERGROUPSREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT ListServerGroupsRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string key;
+		std::string value;
+	};
+	ListServerGroupsRequest();
+	~ListServerGroupsRequest();
+	std::vector<std::string> getServerGroupNames() const;
+	void setServerGroupNames(const std::vector<std::string> &serverGroupNames);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::vector<std::string> getServerGroupIds() const;
+	void setServerGroupIds(const std::vector<std::string> &serverGroupIds);
+	std::string getServerGroupType() const;
+	void setServerGroupType(const std::string &serverGroupType);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+
+private:
+	std::vector<std::string> serverGroupNames_;
+	std::string resourceGroupId_;
+	std::string nextToken_;
+	std::string regionId_;
+	std::vector<Tag> tag_;
+	std::vector<std::string> serverGroupIds_;
+	std::string serverGroupType_;
+	std::string vpcId_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_LISTSERVERGROUPSREQUEST_H_

nlb/include/alibabacloud/nlb/model/ListServerGroupsResult.h

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_LISTSERVERGROUPSRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_LISTSERVERGROUPSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT ListServerGroupsResult : public ServiceResult
+			{
+			public:
+				struct ServerGroup
+				{
+					struct HealthCheck
+					{
+						int healthCheckInterval;
+						int healthCheckConnectPort;
+						std::string healthCheckUrl;
+						int unhealthyThreshold;
+						int healthyThreshold;
+						std::string httpCheckMethod;
+						int healthCheckConnectTimeout;
+						std::string healthCheckDomain;
+						bool healthCheckEnabled;
+						std::vector<std::string> healthCheckHttpCode;
+						std::string healthCheckType;
+					};
+					struct Tag
+					{
+						std::string value;
+						std::string key;
+					};
+					std::vector<std::string> relatedLoadBalancerIds;
+					std::string resourceGroupId;
+					std::string scheduler;
+					std::string addressIPVersion;
+					HealthCheck healthCheck;
+					std::string serverGroupId;
+					int serverCount;
+					std::string serverGroupType;
+					bool preserveClientIpEnabled;
+					std::string serverGroupStatus;
+					bool persistenceEnabled;
+					bool connectionDrainEnabled;
+					int connectionDrainTimeout;
+					int persistenceTimeout;
+					std::string vpcId;
+					bool anyPortEnabled;
+					std::string quicVersion;
+					std::string regionId;
+					std::string protocol;
+					std::vector<ServerGroup::Tag> tags;
+					std::string serverGroupName;
+					long aliUid;
+				};
+
+
+				ListServerGroupsResult();
+				explicit ListServerGroupsResult(const std::string &payload);
+				~ListServerGroupsResult();
+				int getTotalCount()const;
+				std::string getMessage()const;
+				std::string getNextToken()const;
+				std::vector<ServerGroup> getServerGroups()const;
+				int getMaxResults()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string message_;
+				std::string nextToken_;
+				std::vector<ServerGroup> serverGroups_;
+				int maxResults_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_LISTSERVERGROUPSRESULT_H_

nlb/include/alibabacloud/nlb/model/ListSystemSecurityPolicyRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_LISTSYSTEMSECURITYPOLICYREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_LISTSYSTEMSECURITYPOLICYREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT ListSystemSecurityPolicyRequest : public RpcServiceRequest {
+public:
+	ListSystemSecurityPolicyRequest();
+	~ListSystemSecurityPolicyRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_LISTSYSTEMSECURITYPOLICYREQUEST_H_

nlb/include/alibabacloud/nlb/model/ListSystemSecurityPolicyResult.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_LISTSYSTEMSECURITYPOLICYRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_LISTSYSTEMSECURITYPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT ListSystemSecurityPolicyResult : public ServiceResult
+			{
+			public:
+				struct SecurityPolicie
+				{
+					std::string tlsVersion;
+					std::string ciphers;
+					std::string securityPolicyId;
+					std::string securityPolicyName;
+				};
+
+
+				ListSystemSecurityPolicyResult();
+				explicit ListSystemSecurityPolicyResult(const std::string &payload);
+				~ListSystemSecurityPolicyResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				std::vector<SecurityPolicie> getSecurityPolicies()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				std::vector<SecurityPolicie> securityPolicies_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_LISTSYSTEMSECURITYPOLICYRESULT_H_

nlb/include/alibabacloud/nlb/model/ListTagResourcesRequest.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_LISTTAGRESOURCESREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_LISTTAGRESOURCESREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT ListTagResourcesRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string key;
+		std::string value;
+	};
+	ListTagResourcesRequest();
+	~ListTagResourcesRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::vector<std::string> getResourceId() const;
+	void setResourceId(const std::vector<std::string> &resourceId);
+	std::string getResourceType() const;
+	void setResourceType(const std::string &resourceType);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+	int getPage() const;
+	void setPage(int page);
+
+private:
+	std::string nextToken_;
+	std::string regionId_;
+	int pageSize_;
+	std::vector<Tag> tag_;
+	std::vector<std::string> resourceId_;
+	std::string resourceType_;
+	int maxResults_;
+	int page_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_LISTTAGRESOURCESREQUEST_H_

nlb/include/alibabacloud/nlb/model/ListTagResourcesResult.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_LISTTAGRESOURCESRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_LISTTAGRESOURCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT ListTagResourcesResult : public ServiceResult
+			{
+			public:
+				struct TagResultModelList
+				{
+					std::string regionNo;
+					std::string category;
+					std::string scope;
+					std::string resourceId;
+					std::string tagKey;
+					std::string resourceType;
+					std::string tagValue;
+					long aliUid;
+				};
+
+
+				ListTagResourcesResult();
+				explicit ListTagResourcesResult(const std::string &payload);
+				~ListTagResourcesResult();
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				std::vector<TagResultModelList> getTagResources()const;
+				int getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string nextToken_;
+				std::vector<TagResultModelList> tagResources_;
+				int maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_LISTTAGRESOURCESRESULT_H_

nlb/include/alibabacloud/nlb/model/LoadBalancerJoinSecurityGroupRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_LOADBALANCERJOINSECURITYGROUPREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_LOADBALANCERJOINSECURITYGROUPREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT LoadBalancerJoinSecurityGroupRequest : public RpcServiceRequest {
+public:
+	LoadBalancerJoinSecurityGroupRequest();
+	~LoadBalancerJoinSecurityGroupRequest();
+	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::vector<std::string> getSecurityGroupIds() const;
+	void setSecurityGroupIds(const std::vector<std::string> &securityGroupIds);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	bool dryRun_;
+	std::vector<std::string> securityGroupIds_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_LOADBALANCERJOINSECURITYGROUPREQUEST_H_

nlb/include/alibabacloud/nlb/model/LoadBalancerJoinSecurityGroupResult.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_NLB_MODEL_LOADBALANCERJOINSECURITYGROUPRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_LOADBALANCERJOINSECURITYGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT LoadBalancerJoinSecurityGroupResult : public ServiceResult
+			{
+			public:
+
+
+				LoadBalancerJoinSecurityGroupResult();
+				explicit LoadBalancerJoinSecurityGroupResult(const std::string &payload);
+				~LoadBalancerJoinSecurityGroupResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_LOADBALANCERJOINSECURITYGROUPRESULT_H_

nlb/include/alibabacloud/nlb/model/LoadBalancerLeaveSecurityGroupRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_LOADBALANCERLEAVESECURITYGROUPREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_LOADBALANCERLEAVESECURITYGROUPREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT LoadBalancerLeaveSecurityGroupRequest : public RpcServiceRequest {
+public:
+	LoadBalancerLeaveSecurityGroupRequest();
+	~LoadBalancerLeaveSecurityGroupRequest();
+	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::vector<std::string> getSecurityGroupIds() const;
+	void setSecurityGroupIds(const std::vector<std::string> &securityGroupIds);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	bool dryRun_;
+	std::vector<std::string> securityGroupIds_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_LOADBALANCERLEAVESECURITYGROUPREQUEST_H_

nlb/include/alibabacloud/nlb/model/LoadBalancerLeaveSecurityGroupResult.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_NLB_MODEL_LOADBALANCERLEAVESECURITYGROUPRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_LOADBALANCERLEAVESECURITYGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT LoadBalancerLeaveSecurityGroupResult : public ServiceResult
+			{
+			public:
+
+
+				LoadBalancerLeaveSecurityGroupResult();
+				explicit LoadBalancerLeaveSecurityGroupResult(const std::string &payload);
+				~LoadBalancerLeaveSecurityGroupResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_LOADBALANCERLEAVESECURITYGROUPRESULT_H_

nlb/include/alibabacloud/nlb/model/MoveResourceGroupRequest.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_MOVERESOURCEGROUPREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_MOVERESOURCEGROUPREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT MoveResourceGroupRequest : public RpcServiceRequest {
+public:
+	MoveResourceGroupRequest();
+	~MoveResourceGroupRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getChannel() const;
+	void setChannel(const std::string &channel);
+	std::string getOwnerIdLoginEmail() const;
+	void setOwnerIdLoginEmail(const std::string &ownerIdLoginEmail);
+	std::string getResourceDescription() const;
+	void setResourceDescription(const std::string &resourceDescription);
+	std::string getCallerBidLoginEmail() const;
+	void setCallerBidLoginEmail(const std::string &callerBidLoginEmail);
+	std::string getCallerUidLoginEmail() const;
+	void setCallerUidLoginEmail(const std::string &callerUidLoginEmail);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getRequestContent() const;
+	void setRequestContent(const std::string &requestContent);
+	std::string getResourceId() const;
+	void setResourceId(const std::string &resourceId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::string getResourceType() const;
+	void setResourceType(const std::string &resourceType);
+	std::string getNewResourceGroupId() const;
+	void setNewResourceGroupId(const std::string &newResourceGroupId);
+	std::string getServiceCode() const;
+	void setServiceCode(const std::string &serviceCode);
+	std::string getResourceName() const;
+	void setResourceName(const std::string &resourceName);
+
+private:
+	std::string clientToken_;
+	std::string channel_;
+	std::string ownerIdLoginEmail_;
+	std::string resourceDescription_;
+	std::string callerBidLoginEmail_;
+	std::string callerUidLoginEmail_;
+	std::string regionId_;
+	std::string requestContent_;
+	std::string resourceId_;
+	bool dryRun_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	std::string resourceType_;
+	std::string newResourceGroupId_;
+	std::string serviceCode_;
+	std::string resourceName_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_MOVERESOURCEGROUPREQUEST_H_

nlb/include/alibabacloud/nlb/model/MoveResourceGroupResult.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_NLB_MODEL_MOVERESOURCEGROUPRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_MOVERESOURCEGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT MoveResourceGroupResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string resourceId;
+					std::string jobId;
+				};
+
+
+				MoveResourceGroupResult();
+				explicit MoveResourceGroupResult(const std::string &payload);
+				~MoveResourceGroupResult();
+				int getHttpStatusCode()const;
+				Data getData()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				Data data_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_MOVERESOURCEGROUPRESULT_H_

nlb/include/alibabacloud/nlb/model/RemoveServersFromServerGroupRequest.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_NLB_MODEL_REMOVESERVERSFROMSERVERGROUPREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_REMOVESERVERSFROMSERVERGROUPREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT RemoveServersFromServerGroupRequest : public RpcServiceRequest {
+public:
+	struct Servers {
+		std::string serverId;
+		std::string serverType;
+		std::string serverIp;
+		int port;
+	};
+	RemoveServersFromServerGroupRequest();
+	~RemoveServersFromServerGroupRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getServerGroupId() const;
+	void setServerGroupId(const std::string &serverGroupId);
+	std::vector<Servers> getServers() const;
+	void setServers(const std::vector<Servers> &servers);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::string serverGroupId_;
+	std::vector<Servers> servers_;
+	std::string regionId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_REMOVESERVERSFROMSERVERGROUPREQUEST_H_

nlb/include/alibabacloud/nlb/model/RemoveServersFromServerGroupResult.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_NLB_MODEL_REMOVESERVERSFROMSERVERGROUPRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_REMOVESERVERSFROMSERVERGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT RemoveServersFromServerGroupResult : public ServiceResult
+			{
+			public:
+
+
+				RemoveServersFromServerGroupResult();
+				explicit RemoveServersFromServerGroupResult(const std::string &payload);
+				~RemoveServersFromServerGroupResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getServerGroupId()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string serverGroupId_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_REMOVESERVERSFROMSERVERGROUPRESULT_H_

nlb/include/alibabacloud/nlb/model/StartListenerRequest.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_NLB_MODEL_STARTLISTENERREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_STARTLISTENERREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT StartListenerRequest : public RpcServiceRequest {
+public:
+	StartListenerRequest();
+	~StartListenerRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::string listenerId_;
+	std::string regionId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_STARTLISTENERREQUEST_H_

nlb/include/alibabacloud/nlb/model/StartListenerResult.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_NLB_MODEL_STARTLISTENERRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_STARTLISTENERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT StartListenerResult : public ServiceResult
+			{
+			public:
+
+
+				StartListenerResult();
+				explicit StartListenerResult(const std::string &payload);
+				~StartListenerResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_STARTLISTENERRESULT_H_

nlb/include/alibabacloud/nlb/model/StartShiftLoadBalancerZonesRequest.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_STARTSHIFTLOADBALANCERZONESREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_STARTSHIFTLOADBALANCERZONESREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT StartShiftLoadBalancerZonesRequest : public RpcServiceRequest {
+public:
+	struct ZoneMappings {
+		std::string vSwitchId;
+		std::string zoneId;
+	};
+	StartShiftLoadBalancerZonesRequest();
+	~StartShiftLoadBalancerZonesRequest();
+	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::vector<ZoneMappings> getZoneMappings() const;
+	void setZoneMappings(const std::vector<ZoneMappings> &zoneMappings);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	bool dryRun_;
+	std::vector<ZoneMappings> zoneMappings_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_STARTSHIFTLOADBALANCERZONESREQUEST_H_

nlb/include/alibabacloud/nlb/model/StartShiftLoadBalancerZonesResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_STARTSHIFTLOADBALANCERZONESRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_STARTSHIFTLOADBALANCERZONESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT StartShiftLoadBalancerZonesResult : public ServiceResult
+			{
+			public:
+
+
+				StartShiftLoadBalancerZonesResult();
+				explicit StartShiftLoadBalancerZonesResult(const std::string &payload);
+				~StartShiftLoadBalancerZonesResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_STARTSHIFTLOADBALANCERZONESRESULT_H_

nlb/include/alibabacloud/nlb/model/StopListenerRequest.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_NLB_MODEL_STOPLISTENERREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_STOPLISTENERREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT StopListenerRequest : public RpcServiceRequest {
+public:
+	StopListenerRequest();
+	~StopListenerRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::string listenerId_;
+	std::string regionId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_STOPLISTENERREQUEST_H_

nlb/include/alibabacloud/nlb/model/StopListenerResult.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_NLB_MODEL_STOPLISTENERRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_STOPLISTENERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT StopListenerResult : public ServiceResult
+			{
+			public:
+
+
+				StopListenerResult();
+				explicit StopListenerResult(const std::string &payload);
+				~StopListenerResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_STOPLISTENERRESULT_H_

nlb/include/alibabacloud/nlb/model/TagResourcesRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_TAGRESOURCESREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_TAGRESOURCESREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT TagResourcesRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string key;
+		std::string value;
+	};
+	TagResourcesRequest();
+	~TagResourcesRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::vector<std::string> getResourceId() const;
+	void setResourceId(const std::vector<std::string> &resourceId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getResourceType() const;
+	void setResourceType(const std::string &resourceType);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	std::vector<Tag> tag_;
+	std::vector<std::string> resourceId_;
+	bool dryRun_;
+	std::string resourceType_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_TAGRESOURCESREQUEST_H_

nlb/include/alibabacloud/nlb/model/TagResourcesResult.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_NLB_MODEL_TAGRESOURCESRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_TAGRESOURCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT TagResourcesResult : public ServiceResult
+			{
+			public:
+
+
+				TagResourcesResult();
+				explicit TagResourcesResult(const std::string &payload);
+				~TagResourcesResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_TAGRESOURCESRESULT_H_

nlb/include/alibabacloud/nlb/model/UntagResourcesRequest.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_NLB_MODEL_UNTAGRESOURCESREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_UNTAGRESOURCESREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT UntagResourcesRequest : public RpcServiceRequest {
+public:
+	UntagResourcesRequest();
+	~UntagResourcesRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getAll() const;
+	void setAll(bool all);
+	std::vector<std::string> getResourceId() const;
+	void setResourceId(const std::vector<std::string> &resourceId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getResourceType() const;
+	void setResourceType(const std::string &resourceType);
+	std::vector<std::string> getTagKey() const;
+	void setTagKey(const std::vector<std::string> &tagKey);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	bool all_;
+	std::vector<std::string> resourceId_;
+	bool dryRun_;
+	std::string resourceType_;
+	std::vector<std::string> tagKey_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_UNTAGRESOURCESREQUEST_H_

nlb/include/alibabacloud/nlb/model/UntagResourcesResult.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_NLB_MODEL_UNTAGRESOURCESRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_UNTAGRESOURCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT UntagResourcesResult : public ServiceResult
+			{
+			public:
+
+
+				UntagResourcesResult();
+				explicit UntagResourcesResult(const std::string &payload);
+				~UntagResourcesResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_UNTAGRESOURCESRESULT_H_

nlb/include/alibabacloud/nlb/model/UpdateListenerAttributeRequest.h

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_NLB_MODEL_UPDATELISTENERATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATELISTENERATTRIBUTEREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT UpdateListenerAttributeRequest : public RpcServiceRequest {
+public:
+	UpdateListenerAttributeRequest();
+	~UpdateListenerAttributeRequest();
+	std::vector<std::string> getCaCertificateIds() const;
+	void setCaCertificateIds(const std::vector<std::string> &caCertificateIds);
+	int getStartPort() const;
+	void setStartPort(int startPort);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getSecSensorEnabled() const;
+	void setSecSensorEnabled(bool secSensorEnabled);
+	std::string getAlpnPolicy() const;
+	void setAlpnPolicy(const std::string &alpnPolicy);
+	int getMss() const;
+	void setMss(int mss);
+	std::string getServerGroupId() const;
+	void setServerGroupId(const std::string &serverGroupId);
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	std::vector<std::string> getCertificateIds() const;
+	void setCertificateIds(const std::vector<std::string> &certificateIds);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getAlpnEnabled() const;
+	void setAlpnEnabled(bool alpnEnabled);
+	int getEndPort() const;
+	void setEndPort(int endPort);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	bool getProxyProtocolEnabled() const;
+	void setProxyProtocolEnabled(bool proxyProtocolEnabled);
+	int getCps() const;
+	void setCps(int cps);
+	std::string getSecurityPolicyId() const;
+	void setSecurityPolicyId(const std::string &securityPolicyId);
+	int getIdleTimeout() const;
+	void setIdleTimeout(int idleTimeout);
+	std::string getListenerDescription() const;
+	void setListenerDescription(const std::string &listenerDescription);
+	bool getCaEnabled() const;
+	void setCaEnabled(bool caEnabled);
+
+private:
+	std::vector<std::string> caCertificateIds_;
+	int startPort_;
+	std::string clientToken_;
+	bool secSensorEnabled_;
+	std::string alpnPolicy_;
+	int mss_;
+	std::string serverGroupId_;
+	std::string listenerId_;
+	std::vector<std::string> certificateIds_;
+	std::string regionId_;
+	bool alpnEnabled_;
+	int endPort_;
+	bool dryRun_;
+	bool proxyProtocolEnabled_;
+	int cps_;
+	std::string securityPolicyId_;
+	int idleTimeout_;
+	std::string listenerDescription_;
+	bool caEnabled_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATELISTENERATTRIBUTEREQUEST_H_

nlb/include/alibabacloud/nlb/model/UpdateListenerAttributeResult.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_NLB_MODEL_UPDATELISTENERATTRIBUTERESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATELISTENERATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT UpdateListenerAttributeResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateListenerAttributeResult();
+				explicit UpdateListenerAttributeResult(const std::string &payload);
+				~UpdateListenerAttributeResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATELISTENERATTRIBUTERESULT_H_

nlb/include/alibabacloud/nlb/model/UpdateLoadBalancerAddressTypeConfigRequest.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_NLB_MODEL_UPDATELOADBALANCERADDRESSTYPECONFIGREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERADDRESSTYPECONFIGREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT UpdateLoadBalancerAddressTypeConfigRequest : public RpcServiceRequest {
+public:
+	struct ZoneMappings {
+		std::string vSwitchId;
+		std::string zoneId;
+		std::string allocationId;
+		std::string eipType;
+	};
+	UpdateLoadBalancerAddressTypeConfigRequest();
+	~UpdateLoadBalancerAddressTypeConfigRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getAddressType() const;
+	void setAddressType(const std::string &addressType);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::vector<ZoneMappings> getZoneMappings() const;
+	void setZoneMappings(const std::vector<ZoneMappings> &zoneMappings);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	std::string addressType_;
+	bool dryRun_;
+	std::vector<ZoneMappings> zoneMappings_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERADDRESSTYPECONFIGREQUEST_H_

nlb/include/alibabacloud/nlb/model/UpdateLoadBalancerAddressTypeConfigResult.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_NLB_MODEL_UPDATELOADBALANCERADDRESSTYPECONFIGRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERADDRESSTYPECONFIGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT UpdateLoadBalancerAddressTypeConfigResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateLoadBalancerAddressTypeConfigResult();
+				explicit UpdateLoadBalancerAddressTypeConfigResult(const std::string &payload);
+				~UpdateLoadBalancerAddressTypeConfigResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERADDRESSTYPECONFIGRESULT_H_

nlb/include/alibabacloud/nlb/model/UpdateLoadBalancerAttributeRequest.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_NLB_MODEL_UPDATELOADBALANCERATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERATTRIBUTEREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT UpdateLoadBalancerAttributeRequest : public RpcServiceRequest {
+public:
+	UpdateLoadBalancerAttributeRequest();
+	~UpdateLoadBalancerAttributeRequest();
+	bool getCrossZoneEnabled() const;
+	void setCrossZoneEnabled(bool crossZoneEnabled);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getLoadBalancerName() const;
+	void setLoadBalancerName(const std::string &loadBalancerName);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	int getCps() const;
+	void setCps(int cps);
+	bool getTrafficAffinityEnabled() const;
+	void setTrafficAffinityEnabled(bool trafficAffinityEnabled);
+	std::vector<std::string> getSecurityGroupIds() const;
+	void setSecurityGroupIds(const std::vector<std::string> &securityGroupIds);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	bool crossZoneEnabled_;
+	std::string clientToken_;
+	std::string loadBalancerName_;
+	std::string regionId_;
+	bool dryRun_;
+	int cps_;
+	bool trafficAffinityEnabled_;
+	std::vector<std::string> securityGroupIds_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERATTRIBUTEREQUEST_H_

nlb/include/alibabacloud/nlb/model/UpdateLoadBalancerAttributeResult.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_NLB_MODEL_UPDATELOADBALANCERATTRIBUTERESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT UpdateLoadBalancerAttributeResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateLoadBalancerAttributeResult();
+				explicit UpdateLoadBalancerAttributeResult(const std::string &payload);
+				~UpdateLoadBalancerAttributeResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERATTRIBUTERESULT_H_

nlb/include/alibabacloud/nlb/model/UpdateLoadBalancerProtectionRequest.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_NLB_MODEL_UPDATELOADBALANCERPROTECTIONREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERPROTECTIONREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT UpdateLoadBalancerProtectionRequest : public RpcServiceRequest {
+public:
+	UpdateLoadBalancerProtectionRequest();
+	~UpdateLoadBalancerProtectionRequest();
+	std::string getDeletionProtectionReason() const;
+	void setDeletionProtectionReason(const std::string &deletionProtectionReason);
+	std::string getModificationProtectionReason() const;
+	void setModificationProtectionReason(const std::string &modificationProtectionReason);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getDeletionProtectionEnabled() const;
+	void setDeletionProtectionEnabled(bool deletionProtectionEnabled);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getModificationProtectionStatus() const;
+	void setModificationProtectionStatus(const std::string &modificationProtectionStatus);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string deletionProtectionReason_;
+	std::string modificationProtectionReason_;
+	std::string clientToken_;
+	bool deletionProtectionEnabled_;
+	std::string regionId_;
+	bool dryRun_;
+	std::string modificationProtectionStatus_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERPROTECTIONREQUEST_H_

nlb/include/alibabacloud/nlb/model/UpdateLoadBalancerProtectionResult.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_NLB_MODEL_UPDATELOADBALANCERPROTECTIONRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERPROTECTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT UpdateLoadBalancerProtectionResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateLoadBalancerProtectionResult();
+				explicit UpdateLoadBalancerProtectionResult(const std::string &payload);
+				~UpdateLoadBalancerProtectionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERPROTECTIONRESULT_H_

nlb/include/alibabacloud/nlb/model/UpdateLoadBalancerZonesRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERZONESREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERZONESREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT UpdateLoadBalancerZonesRequest : public RpcServiceRequest {
+public:
+	struct ZoneMappings {
+		std::string vSwitchId;
+		std::string zoneId;
+		std::string privateIPv4Address;
+		std::string allocationId;
+		std::string eipType;
+	};
+	UpdateLoadBalancerZonesRequest();
+	~UpdateLoadBalancerZonesRequest();
+	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::vector<ZoneMappings> getZoneMappings() const;
+	void setZoneMappings(const std::vector<ZoneMappings> &zoneMappings);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	bool dryRun_;
+	std::vector<ZoneMappings> zoneMappings_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERZONESREQUEST_H_

nlb/include/alibabacloud/nlb/model/UpdateLoadBalancerZonesResult.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_NLB_MODEL_UPDATELOADBALANCERZONESRESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERZONESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT UpdateLoadBalancerZonesResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateLoadBalancerZonesResult();
+				explicit UpdateLoadBalancerZonesResult(const std::string &payload);
+				~UpdateLoadBalancerZonesResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATELOADBALANCERZONESRESULT_H_

nlb/include/alibabacloud/nlb/model/UpdateSecurityPolicyAttributeRequest.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_NLB_MODEL_UPDATESECURITYPOLICYATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATESECURITYPOLICYATTRIBUTEREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT UpdateSecurityPolicyAttributeRequest : public RpcServiceRequest {
+public:
+	UpdateSecurityPolicyAttributeRequest();
+	~UpdateSecurityPolicyAttributeRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<std::string> getCiphers() const;
+	void setCiphers(const std::vector<std::string> &ciphers);
+	std::vector<std::string> getTlsVersions() const;
+	void setTlsVersions(const std::vector<std::string> &tlsVersions);
+	std::string getSecurityPolicyName() const;
+	void setSecurityPolicyName(const std::string &securityPolicyName);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getSecurityPolicyId() const;
+	void setSecurityPolicyId(const std::string &securityPolicyId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	std::vector<std::string> ciphers_;
+	std::vector<std::string> tlsVersions_;
+	std::string securityPolicyName_;
+	bool dryRun_;
+	std::string securityPolicyId_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATESECURITYPOLICYATTRIBUTEREQUEST_H_

nlb/include/alibabacloud/nlb/model/UpdateSecurityPolicyAttributeResult.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_NLB_MODEL_UPDATESECURITYPOLICYATTRIBUTERESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATESECURITYPOLICYATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT UpdateSecurityPolicyAttributeResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateSecurityPolicyAttributeResult();
+				explicit UpdateSecurityPolicyAttributeResult(const std::string &payload);
+				~UpdateSecurityPolicyAttributeResult();
+				std::string getSecurityPolicyId()const;
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string securityPolicyId_;
+				std::string message_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATESECURITYPOLICYATTRIBUTERESULT_H_

nlb/include/alibabacloud/nlb/model/UpdateServerGroupAttributeRequest.h

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_UPDATESERVERGROUPATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATESERVERGROUPATTRIBUTEREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT UpdateServerGroupAttributeRequest : public RpcServiceRequest {
+public:
+	struct HealthCheckConfig {
+		bool healthCheckEnabled;
+		std::string healthCheckType;
+		int healthCheckConnectPort;
+		int healthyThreshold;
+		int unhealthyThreshold;
+		int healthCheckConnectTimeout;
+		int healthCheckInterval;
+		std::string healthCheckDomain;
+		std::string healthCheckUrl;
+		std::string string;
+		std::vector<std::string> healthCheckHttpCode;
+		std::string httpCheckMethod;
+	};
+	UpdateServerGroupAttributeRequest();
+	~UpdateServerGroupAttributeRequest();
+	std::string getQuicVersion() const;
+	void setQuicVersion(const std::string &quicVersion);
+	std::string getServerGroupName() const;
+	void setServerGroupName(const std::string &serverGroupName);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getPreserveClientIpEnabled() const;
+	void setPreserveClientIpEnabled(bool preserveClientIpEnabled);
+	HealthCheckConfig getHealthCheckConfig() const;
+	void setHealthCheckConfig(const HealthCheckConfig &healthCheckConfig);
+	std::string getServerGroupId() const;
+	void setServerGroupId(const std::string &serverGroupId);
+	std::string getScheduler() const;
+	void setScheduler(const std::string &scheduler);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getPersistenceEnabled() const;
+	void setPersistenceEnabled(bool persistenceEnabled);
+	int getPersistenceTimeout() const;
+	void setPersistenceTimeout(int persistenceTimeout);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	bool getConnectionDrainEnabled() const;
+	void setConnectionDrainEnabled(bool connectionDrainEnabled);
+	int getConnectionDrainTimeout() const;
+	void setConnectionDrainTimeout(int connectionDrainTimeout);
+
+private:
+	std::string quicVersion_;
+	std::string serverGroupName_;
+	std::string clientToken_;
+	bool preserveClientIpEnabled_;
+	HealthCheckConfig healthCheckConfig_;
+	std::string serverGroupId_;
+	std::string scheduler_;
+	std::string regionId_;
+	bool persistenceEnabled_;
+	int persistenceTimeout_;
+	bool dryRun_;
+	bool connectionDrainEnabled_;
+	int connectionDrainTimeout_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATESERVERGROUPATTRIBUTEREQUEST_H_

nlb/include/alibabacloud/nlb/model/UpdateServerGroupAttributeResult.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_NLB_MODEL_UPDATESERVERGROUPATTRIBUTERESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATESERVERGROUPATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT UpdateServerGroupAttributeResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateServerGroupAttributeResult();
+				explicit UpdateServerGroupAttributeResult(const std::string &payload);
+				~UpdateServerGroupAttributeResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getServerGroupId()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string serverGroupId_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATESERVERGROUPATTRIBUTERESULT_H_

nlb/include/alibabacloud/nlb/model/UpdateServerGroupServersAttributeRequest.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLB_MODEL_UPDATESERVERGROUPSERVERSATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATESERVERGROUPSERVERSATTRIBUTEREQUEST_H_
+
+#include <alibabacloud/nlb/NlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nlb {
+namespace Model {
+class ALIBABACLOUD_NLB_EXPORT UpdateServerGroupServersAttributeRequest : public RpcServiceRequest {
+public:
+	struct Servers {
+		std::string serverId;
+		std::string serverType;
+		std::string serverIp;
+		int port;
+		int weight;
+		std::string description;
+	};
+	UpdateServerGroupServersAttributeRequest();
+	~UpdateServerGroupServersAttributeRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getServerGroupId() const;
+	void setServerGroupId(const std::string &serverGroupId);
+	std::vector<Servers> getServers() const;
+	void setServers(const std::vector<Servers> &servers);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::string serverGroupId_;
+	std::vector<Servers> servers_;
+	std::string regionId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Nlb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATESERVERGROUPSERVERSATTRIBUTEREQUEST_H_

nlb/include/alibabacloud/nlb/model/UpdateServerGroupServersAttributeResult.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_NLB_MODEL_UPDATESERVERGROUPSERVERSATTRIBUTERESULT_H_
+#define ALIBABACLOUD_NLB_MODEL_UPDATESERVERGROUPSERVERSATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlb/NlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLB_EXPORT UpdateServerGroupServersAttributeResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateServerGroupServersAttributeResult();
+				explicit UpdateServerGroupServersAttributeResult(const std::string &payload);
+				~UpdateServerGroupServersAttributeResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getServerGroupId()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string serverGroupId_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string code_;
+				bool success_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLB_MODEL_UPDATESERVERGROUPSERVERSATTRIBUTERESULT_H_

nlb/src/NlbClient.cc

@@ -0,0 +1,1745 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/nlb/NlbClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Nlb;
+using namespace AlibabaCloud::Nlb::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "Nlb";
+}
+
+NlbClient::NlbClient(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, "nlb");
+}
+
+NlbClient::NlbClient(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, "nlb");
+}
+
+NlbClient::NlbClient(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, "nlb");
+}
+
+NlbClient::~NlbClient()
+{}
+
+NlbClient::AddServersToServerGroupOutcome NlbClient::addServersToServerGroup(const AddServersToServerGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddServersToServerGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddServersToServerGroupOutcome(AddServersToServerGroupResult(outcome.result()));
+	else
+		return AddServersToServerGroupOutcome(outcome.error());
+}
+
+void NlbClient::addServersToServerGroupAsync(const AddServersToServerGroupRequest& request, const AddServersToServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addServersToServerGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::AddServersToServerGroupOutcomeCallable NlbClient::addServersToServerGroupCallable(const AddServersToServerGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddServersToServerGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->addServersToServerGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::AssociateAdditionalCertificatesWithListenerOutcome NlbClient::associateAdditionalCertificatesWithListener(const AssociateAdditionalCertificatesWithListenerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AssociateAdditionalCertificatesWithListenerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AssociateAdditionalCertificatesWithListenerOutcome(AssociateAdditionalCertificatesWithListenerResult(outcome.result()));
+	else
+		return AssociateAdditionalCertificatesWithListenerOutcome(outcome.error());
+}
+
+void NlbClient::associateAdditionalCertificatesWithListenerAsync(const AssociateAdditionalCertificatesWithListenerRequest& request, const AssociateAdditionalCertificatesWithListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, associateAdditionalCertificatesWithListener(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::AssociateAdditionalCertificatesWithListenerOutcomeCallable NlbClient::associateAdditionalCertificatesWithListenerCallable(const AssociateAdditionalCertificatesWithListenerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AssociateAdditionalCertificatesWithListenerOutcome()>>(
+			[this, request]()
+			{
+			return this->associateAdditionalCertificatesWithListener(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::AttachCommonBandwidthPackageToLoadBalancerOutcome NlbClient::attachCommonBandwidthPackageToLoadBalancer(const AttachCommonBandwidthPackageToLoadBalancerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AttachCommonBandwidthPackageToLoadBalancerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AttachCommonBandwidthPackageToLoadBalancerOutcome(AttachCommonBandwidthPackageToLoadBalancerResult(outcome.result()));
+	else
+		return AttachCommonBandwidthPackageToLoadBalancerOutcome(outcome.error());
+}
+
+void NlbClient::attachCommonBandwidthPackageToLoadBalancerAsync(const AttachCommonBandwidthPackageToLoadBalancerRequest& request, const AttachCommonBandwidthPackageToLoadBalancerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, attachCommonBandwidthPackageToLoadBalancer(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::AttachCommonBandwidthPackageToLoadBalancerOutcomeCallable NlbClient::attachCommonBandwidthPackageToLoadBalancerCallable(const AttachCommonBandwidthPackageToLoadBalancerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AttachCommonBandwidthPackageToLoadBalancerOutcome()>>(
+			[this, request]()
+			{
+			return this->attachCommonBandwidthPackageToLoadBalancer(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::CancelShiftLoadBalancerZonesOutcome NlbClient::cancelShiftLoadBalancerZones(const CancelShiftLoadBalancerZonesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CancelShiftLoadBalancerZonesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CancelShiftLoadBalancerZonesOutcome(CancelShiftLoadBalancerZonesResult(outcome.result()));
+	else
+		return CancelShiftLoadBalancerZonesOutcome(outcome.error());
+}
+
+void NlbClient::cancelShiftLoadBalancerZonesAsync(const CancelShiftLoadBalancerZonesRequest& request, const CancelShiftLoadBalancerZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, cancelShiftLoadBalancerZones(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::CancelShiftLoadBalancerZonesOutcomeCallable NlbClient::cancelShiftLoadBalancerZonesCallable(const CancelShiftLoadBalancerZonesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CancelShiftLoadBalancerZonesOutcome()>>(
+			[this, request]()
+			{
+			return this->cancelShiftLoadBalancerZones(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::CreateListenerOutcome NlbClient::createListener(const CreateListenerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateListenerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateListenerOutcome(CreateListenerResult(outcome.result()));
+	else
+		return CreateListenerOutcome(outcome.error());
+}
+
+void NlbClient::createListenerAsync(const CreateListenerRequest& request, const CreateListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createListener(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::CreateListenerOutcomeCallable NlbClient::createListenerCallable(const CreateListenerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateListenerOutcome()>>(
+			[this, request]()
+			{
+			return this->createListener(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::CreateLoadBalancerOutcome NlbClient::createLoadBalancer(const CreateLoadBalancerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateLoadBalancerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateLoadBalancerOutcome(CreateLoadBalancerResult(outcome.result()));
+	else
+		return CreateLoadBalancerOutcome(outcome.error());
+}
+
+void NlbClient::createLoadBalancerAsync(const CreateLoadBalancerRequest& request, const CreateLoadBalancerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createLoadBalancer(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::CreateLoadBalancerOutcomeCallable NlbClient::createLoadBalancerCallable(const CreateLoadBalancerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateLoadBalancerOutcome()>>(
+			[this, request]()
+			{
+			return this->createLoadBalancer(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::CreateSecurityPolicyOutcome NlbClient::createSecurityPolicy(const CreateSecurityPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateSecurityPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateSecurityPolicyOutcome(CreateSecurityPolicyResult(outcome.result()));
+	else
+		return CreateSecurityPolicyOutcome(outcome.error());
+}
+
+void NlbClient::createSecurityPolicyAsync(const CreateSecurityPolicyRequest& request, const CreateSecurityPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createSecurityPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::CreateSecurityPolicyOutcomeCallable NlbClient::createSecurityPolicyCallable(const CreateSecurityPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateSecurityPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->createSecurityPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::CreateServerGroupOutcome NlbClient::createServerGroup(const CreateServerGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateServerGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateServerGroupOutcome(CreateServerGroupResult(outcome.result()));
+	else
+		return CreateServerGroupOutcome(outcome.error());
+}
+
+void NlbClient::createServerGroupAsync(const CreateServerGroupRequest& request, const CreateServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createServerGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::CreateServerGroupOutcomeCallable NlbClient::createServerGroupCallable(const CreateServerGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateServerGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->createServerGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::DeleteListenerOutcome NlbClient::deleteListener(const DeleteListenerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteListenerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteListenerOutcome(DeleteListenerResult(outcome.result()));
+	else
+		return DeleteListenerOutcome(outcome.error());
+}
+
+void NlbClient::deleteListenerAsync(const DeleteListenerRequest& request, const DeleteListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteListener(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::DeleteListenerOutcomeCallable NlbClient::deleteListenerCallable(const DeleteListenerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteListenerOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteListener(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::DeleteLoadBalancerOutcome NlbClient::deleteLoadBalancer(const DeleteLoadBalancerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteLoadBalancerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteLoadBalancerOutcome(DeleteLoadBalancerResult(outcome.result()));
+	else
+		return DeleteLoadBalancerOutcome(outcome.error());
+}
+
+void NlbClient::deleteLoadBalancerAsync(const DeleteLoadBalancerRequest& request, const DeleteLoadBalancerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteLoadBalancer(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::DeleteLoadBalancerOutcomeCallable NlbClient::deleteLoadBalancerCallable(const DeleteLoadBalancerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteLoadBalancerOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteLoadBalancer(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::DeleteSecurityPolicyOutcome NlbClient::deleteSecurityPolicy(const DeleteSecurityPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteSecurityPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteSecurityPolicyOutcome(DeleteSecurityPolicyResult(outcome.result()));
+	else
+		return DeleteSecurityPolicyOutcome(outcome.error());
+}
+
+void NlbClient::deleteSecurityPolicyAsync(const DeleteSecurityPolicyRequest& request, const DeleteSecurityPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteSecurityPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::DeleteSecurityPolicyOutcomeCallable NlbClient::deleteSecurityPolicyCallable(const DeleteSecurityPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteSecurityPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteSecurityPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::DeleteServerGroupOutcome NlbClient::deleteServerGroup(const DeleteServerGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteServerGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteServerGroupOutcome(DeleteServerGroupResult(outcome.result()));
+	else
+		return DeleteServerGroupOutcome(outcome.error());
+}
+
+void NlbClient::deleteServerGroupAsync(const DeleteServerGroupRequest& request, const DeleteServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteServerGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::DeleteServerGroupOutcomeCallable NlbClient::deleteServerGroupCallable(const DeleteServerGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteServerGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteServerGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::DescribeRegionsOutcome NlbClient::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 NlbClient::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));
+}
+
+NlbClient::DescribeRegionsOutcomeCallable NlbClient::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();
+}
+
+NlbClient::DescribeZonesOutcome NlbClient::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 NlbClient::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));
+}
+
+NlbClient::DescribeZonesOutcomeCallable NlbClient::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();
+}
+
+NlbClient::DetachCommonBandwidthPackageFromLoadBalancerOutcome NlbClient::detachCommonBandwidthPackageFromLoadBalancer(const DetachCommonBandwidthPackageFromLoadBalancerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetachCommonBandwidthPackageFromLoadBalancerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetachCommonBandwidthPackageFromLoadBalancerOutcome(DetachCommonBandwidthPackageFromLoadBalancerResult(outcome.result()));
+	else
+		return DetachCommonBandwidthPackageFromLoadBalancerOutcome(outcome.error());
+}
+
+void NlbClient::detachCommonBandwidthPackageFromLoadBalancerAsync(const DetachCommonBandwidthPackageFromLoadBalancerRequest& request, const DetachCommonBandwidthPackageFromLoadBalancerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detachCommonBandwidthPackageFromLoadBalancer(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::DetachCommonBandwidthPackageFromLoadBalancerOutcomeCallable NlbClient::detachCommonBandwidthPackageFromLoadBalancerCallable(const DetachCommonBandwidthPackageFromLoadBalancerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetachCommonBandwidthPackageFromLoadBalancerOutcome()>>(
+			[this, request]()
+			{
+			return this->detachCommonBandwidthPackageFromLoadBalancer(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::DisableLoadBalancerIpv6InternetOutcome NlbClient::disableLoadBalancerIpv6Internet(const DisableLoadBalancerIpv6InternetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DisableLoadBalancerIpv6InternetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DisableLoadBalancerIpv6InternetOutcome(DisableLoadBalancerIpv6InternetResult(outcome.result()));
+	else
+		return DisableLoadBalancerIpv6InternetOutcome(outcome.error());
+}
+
+void NlbClient::disableLoadBalancerIpv6InternetAsync(const DisableLoadBalancerIpv6InternetRequest& request, const DisableLoadBalancerIpv6InternetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, disableLoadBalancerIpv6Internet(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::DisableLoadBalancerIpv6InternetOutcomeCallable NlbClient::disableLoadBalancerIpv6InternetCallable(const DisableLoadBalancerIpv6InternetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DisableLoadBalancerIpv6InternetOutcome()>>(
+			[this, request]()
+			{
+			return this->disableLoadBalancerIpv6Internet(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::DisassociateAdditionalCertificatesWithListenerOutcome NlbClient::disassociateAdditionalCertificatesWithListener(const DisassociateAdditionalCertificatesWithListenerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DisassociateAdditionalCertificatesWithListenerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DisassociateAdditionalCertificatesWithListenerOutcome(DisassociateAdditionalCertificatesWithListenerResult(outcome.result()));
+	else
+		return DisassociateAdditionalCertificatesWithListenerOutcome(outcome.error());
+}
+
+void NlbClient::disassociateAdditionalCertificatesWithListenerAsync(const DisassociateAdditionalCertificatesWithListenerRequest& request, const DisassociateAdditionalCertificatesWithListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, disassociateAdditionalCertificatesWithListener(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::DisassociateAdditionalCertificatesWithListenerOutcomeCallable NlbClient::disassociateAdditionalCertificatesWithListenerCallable(const DisassociateAdditionalCertificatesWithListenerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DisassociateAdditionalCertificatesWithListenerOutcome()>>(
+			[this, request]()
+			{
+			return this->disassociateAdditionalCertificatesWithListener(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::EnableLoadBalancerIpv6InternetOutcome NlbClient::enableLoadBalancerIpv6Internet(const EnableLoadBalancerIpv6InternetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnableLoadBalancerIpv6InternetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnableLoadBalancerIpv6InternetOutcome(EnableLoadBalancerIpv6InternetResult(outcome.result()));
+	else
+		return EnableLoadBalancerIpv6InternetOutcome(outcome.error());
+}
+
+void NlbClient::enableLoadBalancerIpv6InternetAsync(const EnableLoadBalancerIpv6InternetRequest& request, const EnableLoadBalancerIpv6InternetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enableLoadBalancerIpv6Internet(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::EnableLoadBalancerIpv6InternetOutcomeCallable NlbClient::enableLoadBalancerIpv6InternetCallable(const EnableLoadBalancerIpv6InternetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnableLoadBalancerIpv6InternetOutcome()>>(
+			[this, request]()
+			{
+			return this->enableLoadBalancerIpv6Internet(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::GetJobStatusOutcome NlbClient::getJobStatus(const GetJobStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetJobStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetJobStatusOutcome(GetJobStatusResult(outcome.result()));
+	else
+		return GetJobStatusOutcome(outcome.error());
+}
+
+void NlbClient::getJobStatusAsync(const GetJobStatusRequest& request, const GetJobStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getJobStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::GetJobStatusOutcomeCallable NlbClient::getJobStatusCallable(const GetJobStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetJobStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->getJobStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::GetListenerAttributeOutcome NlbClient::getListenerAttribute(const GetListenerAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetListenerAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetListenerAttributeOutcome(GetListenerAttributeResult(outcome.result()));
+	else
+		return GetListenerAttributeOutcome(outcome.error());
+}
+
+void NlbClient::getListenerAttributeAsync(const GetListenerAttributeRequest& request, const GetListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getListenerAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::GetListenerAttributeOutcomeCallable NlbClient::getListenerAttributeCallable(const GetListenerAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetListenerAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->getListenerAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::GetListenerHealthStatusOutcome NlbClient::getListenerHealthStatus(const GetListenerHealthStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetListenerHealthStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetListenerHealthStatusOutcome(GetListenerHealthStatusResult(outcome.result()));
+	else
+		return GetListenerHealthStatusOutcome(outcome.error());
+}
+
+void NlbClient::getListenerHealthStatusAsync(const GetListenerHealthStatusRequest& request, const GetListenerHealthStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getListenerHealthStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::GetListenerHealthStatusOutcomeCallable NlbClient::getListenerHealthStatusCallable(const GetListenerHealthStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetListenerHealthStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->getListenerHealthStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::GetLoadBalancerAttributeOutcome NlbClient::getLoadBalancerAttribute(const GetLoadBalancerAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetLoadBalancerAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetLoadBalancerAttributeOutcome(GetLoadBalancerAttributeResult(outcome.result()));
+	else
+		return GetLoadBalancerAttributeOutcome(outcome.error());
+}
+
+void NlbClient::getLoadBalancerAttributeAsync(const GetLoadBalancerAttributeRequest& request, const GetLoadBalancerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getLoadBalancerAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::GetLoadBalancerAttributeOutcomeCallable NlbClient::getLoadBalancerAttributeCallable(const GetLoadBalancerAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetLoadBalancerAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->getLoadBalancerAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::ListListenerCertificatesOutcome NlbClient::listListenerCertificates(const ListListenerCertificatesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListListenerCertificatesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListListenerCertificatesOutcome(ListListenerCertificatesResult(outcome.result()));
+	else
+		return ListListenerCertificatesOutcome(outcome.error());
+}
+
+void NlbClient::listListenerCertificatesAsync(const ListListenerCertificatesRequest& request, const ListListenerCertificatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listListenerCertificates(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::ListListenerCertificatesOutcomeCallable NlbClient::listListenerCertificatesCallable(const ListListenerCertificatesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListListenerCertificatesOutcome()>>(
+			[this, request]()
+			{
+			return this->listListenerCertificates(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::ListListenersOutcome NlbClient::listListeners(const ListListenersRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListListenersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListListenersOutcome(ListListenersResult(outcome.result()));
+	else
+		return ListListenersOutcome(outcome.error());
+}
+
+void NlbClient::listListenersAsync(const ListListenersRequest& request, const ListListenersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listListeners(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::ListListenersOutcomeCallable NlbClient::listListenersCallable(const ListListenersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListListenersOutcome()>>(
+			[this, request]()
+			{
+			return this->listListeners(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::ListLoadBalancersOutcome NlbClient::listLoadBalancers(const ListLoadBalancersRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListLoadBalancersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListLoadBalancersOutcome(ListLoadBalancersResult(outcome.result()));
+	else
+		return ListLoadBalancersOutcome(outcome.error());
+}
+
+void NlbClient::listLoadBalancersAsync(const ListLoadBalancersRequest& request, const ListLoadBalancersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listLoadBalancers(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::ListLoadBalancersOutcomeCallable NlbClient::listLoadBalancersCallable(const ListLoadBalancersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListLoadBalancersOutcome()>>(
+			[this, request]()
+			{
+			return this->listLoadBalancers(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::ListSecurityPolicyOutcome NlbClient::listSecurityPolicy(const ListSecurityPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListSecurityPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListSecurityPolicyOutcome(ListSecurityPolicyResult(outcome.result()));
+	else
+		return ListSecurityPolicyOutcome(outcome.error());
+}
+
+void NlbClient::listSecurityPolicyAsync(const ListSecurityPolicyRequest& request, const ListSecurityPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listSecurityPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::ListSecurityPolicyOutcomeCallable NlbClient::listSecurityPolicyCallable(const ListSecurityPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListSecurityPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->listSecurityPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::ListServerGroupServersOutcome NlbClient::listServerGroupServers(const ListServerGroupServersRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListServerGroupServersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListServerGroupServersOutcome(ListServerGroupServersResult(outcome.result()));
+	else
+		return ListServerGroupServersOutcome(outcome.error());
+}
+
+void NlbClient::listServerGroupServersAsync(const ListServerGroupServersRequest& request, const ListServerGroupServersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listServerGroupServers(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::ListServerGroupServersOutcomeCallable NlbClient::listServerGroupServersCallable(const ListServerGroupServersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListServerGroupServersOutcome()>>(
+			[this, request]()
+			{
+			return this->listServerGroupServers(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::ListServerGroupsOutcome NlbClient::listServerGroups(const ListServerGroupsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListServerGroupsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListServerGroupsOutcome(ListServerGroupsResult(outcome.result()));
+	else
+		return ListServerGroupsOutcome(outcome.error());
+}
+
+void NlbClient::listServerGroupsAsync(const ListServerGroupsRequest& request, const ListServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listServerGroups(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::ListServerGroupsOutcomeCallable NlbClient::listServerGroupsCallable(const ListServerGroupsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListServerGroupsOutcome()>>(
+			[this, request]()
+			{
+			return this->listServerGroups(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::ListSystemSecurityPolicyOutcome NlbClient::listSystemSecurityPolicy(const ListSystemSecurityPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListSystemSecurityPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListSystemSecurityPolicyOutcome(ListSystemSecurityPolicyResult(outcome.result()));
+	else
+		return ListSystemSecurityPolicyOutcome(outcome.error());
+}
+
+void NlbClient::listSystemSecurityPolicyAsync(const ListSystemSecurityPolicyRequest& request, const ListSystemSecurityPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listSystemSecurityPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::ListSystemSecurityPolicyOutcomeCallable NlbClient::listSystemSecurityPolicyCallable(const ListSystemSecurityPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListSystemSecurityPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->listSystemSecurityPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::ListTagResourcesOutcome NlbClient::listTagResources(const ListTagResourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListTagResourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListTagResourcesOutcome(ListTagResourcesResult(outcome.result()));
+	else
+		return ListTagResourcesOutcome(outcome.error());
+}
+
+void NlbClient::listTagResourcesAsync(const ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listTagResources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::ListTagResourcesOutcomeCallable NlbClient::listTagResourcesCallable(const ListTagResourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListTagResourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->listTagResources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::LoadBalancerJoinSecurityGroupOutcome NlbClient::loadBalancerJoinSecurityGroup(const LoadBalancerJoinSecurityGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return LoadBalancerJoinSecurityGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return LoadBalancerJoinSecurityGroupOutcome(LoadBalancerJoinSecurityGroupResult(outcome.result()));
+	else
+		return LoadBalancerJoinSecurityGroupOutcome(outcome.error());
+}
+
+void NlbClient::loadBalancerJoinSecurityGroupAsync(const LoadBalancerJoinSecurityGroupRequest& request, const LoadBalancerJoinSecurityGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, loadBalancerJoinSecurityGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::LoadBalancerJoinSecurityGroupOutcomeCallable NlbClient::loadBalancerJoinSecurityGroupCallable(const LoadBalancerJoinSecurityGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<LoadBalancerJoinSecurityGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->loadBalancerJoinSecurityGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::LoadBalancerLeaveSecurityGroupOutcome NlbClient::loadBalancerLeaveSecurityGroup(const LoadBalancerLeaveSecurityGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return LoadBalancerLeaveSecurityGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return LoadBalancerLeaveSecurityGroupOutcome(LoadBalancerLeaveSecurityGroupResult(outcome.result()));
+	else
+		return LoadBalancerLeaveSecurityGroupOutcome(outcome.error());
+}
+
+void NlbClient::loadBalancerLeaveSecurityGroupAsync(const LoadBalancerLeaveSecurityGroupRequest& request, const LoadBalancerLeaveSecurityGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, loadBalancerLeaveSecurityGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::LoadBalancerLeaveSecurityGroupOutcomeCallable NlbClient::loadBalancerLeaveSecurityGroupCallable(const LoadBalancerLeaveSecurityGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<LoadBalancerLeaveSecurityGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->loadBalancerLeaveSecurityGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::MoveResourceGroupOutcome NlbClient::moveResourceGroup(const MoveResourceGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return MoveResourceGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return MoveResourceGroupOutcome(MoveResourceGroupResult(outcome.result()));
+	else
+		return MoveResourceGroupOutcome(outcome.error());
+}
+
+void NlbClient::moveResourceGroupAsync(const MoveResourceGroupRequest& request, const MoveResourceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, moveResourceGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::MoveResourceGroupOutcomeCallable NlbClient::moveResourceGroupCallable(const MoveResourceGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<MoveResourceGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->moveResourceGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::RemoveServersFromServerGroupOutcome NlbClient::removeServersFromServerGroup(const RemoveServersFromServerGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RemoveServersFromServerGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RemoveServersFromServerGroupOutcome(RemoveServersFromServerGroupResult(outcome.result()));
+	else
+		return RemoveServersFromServerGroupOutcome(outcome.error());
+}
+
+void NlbClient::removeServersFromServerGroupAsync(const RemoveServersFromServerGroupRequest& request, const RemoveServersFromServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, removeServersFromServerGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::RemoveServersFromServerGroupOutcomeCallable NlbClient::removeServersFromServerGroupCallable(const RemoveServersFromServerGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RemoveServersFromServerGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->removeServersFromServerGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::StartListenerOutcome NlbClient::startListener(const StartListenerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartListenerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartListenerOutcome(StartListenerResult(outcome.result()));
+	else
+		return StartListenerOutcome(outcome.error());
+}
+
+void NlbClient::startListenerAsync(const StartListenerRequest& request, const StartListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startListener(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::StartListenerOutcomeCallable NlbClient::startListenerCallable(const StartListenerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartListenerOutcome()>>(
+			[this, request]()
+			{
+			return this->startListener(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::StartShiftLoadBalancerZonesOutcome NlbClient::startShiftLoadBalancerZones(const StartShiftLoadBalancerZonesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartShiftLoadBalancerZonesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartShiftLoadBalancerZonesOutcome(StartShiftLoadBalancerZonesResult(outcome.result()));
+	else
+		return StartShiftLoadBalancerZonesOutcome(outcome.error());
+}
+
+void NlbClient::startShiftLoadBalancerZonesAsync(const StartShiftLoadBalancerZonesRequest& request, const StartShiftLoadBalancerZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startShiftLoadBalancerZones(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::StartShiftLoadBalancerZonesOutcomeCallable NlbClient::startShiftLoadBalancerZonesCallable(const StartShiftLoadBalancerZonesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartShiftLoadBalancerZonesOutcome()>>(
+			[this, request]()
+			{
+			return this->startShiftLoadBalancerZones(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::StopListenerOutcome NlbClient::stopListener(const StopListenerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopListenerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopListenerOutcome(StopListenerResult(outcome.result()));
+	else
+		return StopListenerOutcome(outcome.error());
+}
+
+void NlbClient::stopListenerAsync(const StopListenerRequest& request, const StopListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopListener(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::StopListenerOutcomeCallable NlbClient::stopListenerCallable(const StopListenerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopListenerOutcome()>>(
+			[this, request]()
+			{
+			return this->stopListener(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::TagResourcesOutcome NlbClient::tagResources(const TagResourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return TagResourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return TagResourcesOutcome(TagResourcesResult(outcome.result()));
+	else
+		return TagResourcesOutcome(outcome.error());
+}
+
+void NlbClient::tagResourcesAsync(const TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, tagResources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::TagResourcesOutcomeCallable NlbClient::tagResourcesCallable(const TagResourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<TagResourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->tagResources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::UntagResourcesOutcome NlbClient::untagResources(const UntagResourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UntagResourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UntagResourcesOutcome(UntagResourcesResult(outcome.result()));
+	else
+		return UntagResourcesOutcome(outcome.error());
+}
+
+void NlbClient::untagResourcesAsync(const UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, untagResources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::UntagResourcesOutcomeCallable NlbClient::untagResourcesCallable(const UntagResourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UntagResourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->untagResources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::UpdateListenerAttributeOutcome NlbClient::updateListenerAttribute(const UpdateListenerAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateListenerAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateListenerAttributeOutcome(UpdateListenerAttributeResult(outcome.result()));
+	else
+		return UpdateListenerAttributeOutcome(outcome.error());
+}
+
+void NlbClient::updateListenerAttributeAsync(const UpdateListenerAttributeRequest& request, const UpdateListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateListenerAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::UpdateListenerAttributeOutcomeCallable NlbClient::updateListenerAttributeCallable(const UpdateListenerAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateListenerAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->updateListenerAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::UpdateLoadBalancerAddressTypeConfigOutcome NlbClient::updateLoadBalancerAddressTypeConfig(const UpdateLoadBalancerAddressTypeConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateLoadBalancerAddressTypeConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateLoadBalancerAddressTypeConfigOutcome(UpdateLoadBalancerAddressTypeConfigResult(outcome.result()));
+	else
+		return UpdateLoadBalancerAddressTypeConfigOutcome(outcome.error());
+}
+
+void NlbClient::updateLoadBalancerAddressTypeConfigAsync(const UpdateLoadBalancerAddressTypeConfigRequest& request, const UpdateLoadBalancerAddressTypeConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateLoadBalancerAddressTypeConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::UpdateLoadBalancerAddressTypeConfigOutcomeCallable NlbClient::updateLoadBalancerAddressTypeConfigCallable(const UpdateLoadBalancerAddressTypeConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateLoadBalancerAddressTypeConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->updateLoadBalancerAddressTypeConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::UpdateLoadBalancerAttributeOutcome NlbClient::updateLoadBalancerAttribute(const UpdateLoadBalancerAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateLoadBalancerAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateLoadBalancerAttributeOutcome(UpdateLoadBalancerAttributeResult(outcome.result()));
+	else
+		return UpdateLoadBalancerAttributeOutcome(outcome.error());
+}
+
+void NlbClient::updateLoadBalancerAttributeAsync(const UpdateLoadBalancerAttributeRequest& request, const UpdateLoadBalancerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateLoadBalancerAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::UpdateLoadBalancerAttributeOutcomeCallable NlbClient::updateLoadBalancerAttributeCallable(const UpdateLoadBalancerAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateLoadBalancerAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->updateLoadBalancerAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::UpdateLoadBalancerProtectionOutcome NlbClient::updateLoadBalancerProtection(const UpdateLoadBalancerProtectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateLoadBalancerProtectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateLoadBalancerProtectionOutcome(UpdateLoadBalancerProtectionResult(outcome.result()));
+	else
+		return UpdateLoadBalancerProtectionOutcome(outcome.error());
+}
+
+void NlbClient::updateLoadBalancerProtectionAsync(const UpdateLoadBalancerProtectionRequest& request, const UpdateLoadBalancerProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateLoadBalancerProtection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::UpdateLoadBalancerProtectionOutcomeCallable NlbClient::updateLoadBalancerProtectionCallable(const UpdateLoadBalancerProtectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateLoadBalancerProtectionOutcome()>>(
+			[this, request]()
+			{
+			return this->updateLoadBalancerProtection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::UpdateLoadBalancerZonesOutcome NlbClient::updateLoadBalancerZones(const UpdateLoadBalancerZonesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateLoadBalancerZonesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateLoadBalancerZonesOutcome(UpdateLoadBalancerZonesResult(outcome.result()));
+	else
+		return UpdateLoadBalancerZonesOutcome(outcome.error());
+}
+
+void NlbClient::updateLoadBalancerZonesAsync(const UpdateLoadBalancerZonesRequest& request, const UpdateLoadBalancerZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateLoadBalancerZones(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::UpdateLoadBalancerZonesOutcomeCallable NlbClient::updateLoadBalancerZonesCallable(const UpdateLoadBalancerZonesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateLoadBalancerZonesOutcome()>>(
+			[this, request]()
+			{
+			return this->updateLoadBalancerZones(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::UpdateSecurityPolicyAttributeOutcome NlbClient::updateSecurityPolicyAttribute(const UpdateSecurityPolicyAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateSecurityPolicyAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateSecurityPolicyAttributeOutcome(UpdateSecurityPolicyAttributeResult(outcome.result()));
+	else
+		return UpdateSecurityPolicyAttributeOutcome(outcome.error());
+}
+
+void NlbClient::updateSecurityPolicyAttributeAsync(const UpdateSecurityPolicyAttributeRequest& request, const UpdateSecurityPolicyAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateSecurityPolicyAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::UpdateSecurityPolicyAttributeOutcomeCallable NlbClient::updateSecurityPolicyAttributeCallable(const UpdateSecurityPolicyAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateSecurityPolicyAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->updateSecurityPolicyAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::UpdateServerGroupAttributeOutcome NlbClient::updateServerGroupAttribute(const UpdateServerGroupAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateServerGroupAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateServerGroupAttributeOutcome(UpdateServerGroupAttributeResult(outcome.result()));
+	else
+		return UpdateServerGroupAttributeOutcome(outcome.error());
+}
+
+void NlbClient::updateServerGroupAttributeAsync(const UpdateServerGroupAttributeRequest& request, const UpdateServerGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateServerGroupAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::UpdateServerGroupAttributeOutcomeCallable NlbClient::updateServerGroupAttributeCallable(const UpdateServerGroupAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateServerGroupAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->updateServerGroupAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NlbClient::UpdateServerGroupServersAttributeOutcome NlbClient::updateServerGroupServersAttribute(const UpdateServerGroupServersAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateServerGroupServersAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateServerGroupServersAttributeOutcome(UpdateServerGroupServersAttributeResult(outcome.result()));
+	else
+		return UpdateServerGroupServersAttributeOutcome(outcome.error());
+}
+
+void NlbClient::updateServerGroupServersAttributeAsync(const UpdateServerGroupServersAttributeRequest& request, const UpdateServerGroupServersAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateServerGroupServersAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NlbClient::UpdateServerGroupServersAttributeOutcomeCallable NlbClient::updateServerGroupServersAttributeCallable(const UpdateServerGroupServersAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateServerGroupServersAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->updateServerGroupServersAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

nlb/src/model/AddServersToServerGroupRequest.cc

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/nlb/model/AddServersToServerGroupRequest.h>
+
+using AlibabaCloud::Nlb::Model::AddServersToServerGroupRequest;
+
+AddServersToServerGroupRequest::AddServersToServerGroupRequest()
+    : RpcServiceRequest("nlb", "2022-04-30", "AddServersToServerGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AddServersToServerGroupRequest::~AddServersToServerGroupRequest() {}
+
+std::string AddServersToServerGroupRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void AddServersToServerGroupRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setBodyParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string AddServersToServerGroupRequest::getServerGroupId() const {
+  return serverGroupId_;
+}
+
+void AddServersToServerGroupRequest::setServerGroupId(const std::string &serverGroupId) {
+  serverGroupId_ = serverGroupId;
+  setBodyParameter(std::string("ServerGroupId"), serverGroupId);
+}
+
+std::vector<AddServersToServerGroupRequest::Servers> AddServersToServerGroupRequest::getServers() const {
+  return servers_;
+}
+
+void AddServersToServerGroupRequest::setServers(const std::vector<AddServersToServerGroupRequest::Servers> &servers) {
+  servers_ = servers;
+  for(int dep1 = 0; dep1 != servers.size(); dep1++) {
+    setBodyParameter(std::string("Servers") + "." + std::to_string(dep1 + 1) + ".ServerId", servers[dep1].serverId);
+    setBodyParameter(std::string("Servers") + "." + std::to_string(dep1 + 1) + ".ServerType", servers[dep1].serverType);
+    setBodyParameter(std::string("Servers") + "." + std::to_string(dep1 + 1) + ".ServerIp", servers[dep1].serverIp);
+    setBodyParameter(std::string("Servers") + "." + std::to_string(dep1 + 1) + ".Port", std::to_string(servers[dep1].port));
+    setBodyParameter(std::string("Servers") + "." + std::to_string(dep1 + 1) + ".Weight", std::to_string(servers[dep1].weight));
+    setBodyParameter(std::string("Servers") + "." + std::to_string(dep1 + 1) + ".Description", servers[dep1].description);
+  }
+}
+
+std::string AddServersToServerGroupRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AddServersToServerGroupRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setBodyParameter(std::string("RegionId"), regionId);
+}
+
+bool AddServersToServerGroupRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void AddServersToServerGroupRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setBodyParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+