Support Alb Open API.

CHANGELOG

@@ -1,3 +1,6 @@
+2021-07-15 Version: 1.36.818
+- Support Alb Open API.
+
 2021-07-15 Version: 1.36.817
 - Generated 2020-01-01 for `ddoscoo`.
 

VERSION

@@ -1 +1 @@
-1.36.817
+1.36.818

alb/CMakeLists.txt

@@ -0,0 +1,350 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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(alb_public_header 
+	include/alibabacloud/alb/AlbClient.h
+	include/alibabacloud/alb/AlbExport.h )
+
+set(alb_public_header_model 
+	include/alibabacloud/alb/model/AddEntriesToAclRequest.h
+	include/alibabacloud/alb/model/AddEntriesToAclResult.h
+	include/alibabacloud/alb/model/AddServersToServerGroupRequest.h
+	include/alibabacloud/alb/model/AddServersToServerGroupResult.h
+	include/alibabacloud/alb/model/AssociateAclsWithListenerRequest.h
+	include/alibabacloud/alb/model/AssociateAclsWithListenerResult.h
+	include/alibabacloud/alb/model/AssociateAdditionalCertificatesWithListenerRequest.h
+	include/alibabacloud/alb/model/AssociateAdditionalCertificatesWithListenerResult.h
+	include/alibabacloud/alb/model/CreateAclRequest.h
+	include/alibabacloud/alb/model/CreateAclResult.h
+	include/alibabacloud/alb/model/CreateHealthCheckTemplateRequest.h
+	include/alibabacloud/alb/model/CreateHealthCheckTemplateResult.h
+	include/alibabacloud/alb/model/CreateListenerRequest.h
+	include/alibabacloud/alb/model/CreateListenerResult.h
+	include/alibabacloud/alb/model/CreateLoadBalancerRequest.h
+	include/alibabacloud/alb/model/CreateLoadBalancerResult.h
+	include/alibabacloud/alb/model/CreateRuleRequest.h
+	include/alibabacloud/alb/model/CreateRuleResult.h
+	include/alibabacloud/alb/model/CreateRulesRequest.h
+	include/alibabacloud/alb/model/CreateRulesResult.h
+	include/alibabacloud/alb/model/CreateSecurityPolicyRequest.h
+	include/alibabacloud/alb/model/CreateSecurityPolicyResult.h
+	include/alibabacloud/alb/model/CreateServerGroupRequest.h
+	include/alibabacloud/alb/model/CreateServerGroupResult.h
+	include/alibabacloud/alb/model/DeleteAclRequest.h
+	include/alibabacloud/alb/model/DeleteAclResult.h
+	include/alibabacloud/alb/model/DeleteHealthCheckTemplatesRequest.h
+	include/alibabacloud/alb/model/DeleteHealthCheckTemplatesResult.h
+	include/alibabacloud/alb/model/DeleteListenerRequest.h
+	include/alibabacloud/alb/model/DeleteListenerResult.h
+	include/alibabacloud/alb/model/DeleteLoadBalancerRequest.h
+	include/alibabacloud/alb/model/DeleteLoadBalancerResult.h
+	include/alibabacloud/alb/model/DeleteRuleRequest.h
+	include/alibabacloud/alb/model/DeleteRuleResult.h
+	include/alibabacloud/alb/model/DeleteRulesRequest.h
+	include/alibabacloud/alb/model/DeleteRulesResult.h
+	include/alibabacloud/alb/model/DeleteSecurityPolicyRequest.h
+	include/alibabacloud/alb/model/DeleteSecurityPolicyResult.h
+	include/alibabacloud/alb/model/DeleteServerGroupRequest.h
+	include/alibabacloud/alb/model/DeleteServerGroupResult.h
+	include/alibabacloud/alb/model/DescribeRegionsRequest.h
+	include/alibabacloud/alb/model/DescribeRegionsResult.h
+	include/alibabacloud/alb/model/DescribeZonesRequest.h
+	include/alibabacloud/alb/model/DescribeZonesResult.h
+	include/alibabacloud/alb/model/DisableDeletionProtectionRequest.h
+	include/alibabacloud/alb/model/DisableDeletionProtectionResult.h
+	include/alibabacloud/alb/model/DisableLoadBalancerAccessLogRequest.h
+	include/alibabacloud/alb/model/DisableLoadBalancerAccessLogResult.h
+	include/alibabacloud/alb/model/DissociateAclsFromListenerRequest.h
+	include/alibabacloud/alb/model/DissociateAclsFromListenerResult.h
+	include/alibabacloud/alb/model/DissociateAdditionalCertificatesFromListenerRequest.h
+	include/alibabacloud/alb/model/DissociateAdditionalCertificatesFromListenerResult.h
+	include/alibabacloud/alb/model/EnableDeletionProtectionRequest.h
+	include/alibabacloud/alb/model/EnableDeletionProtectionResult.h
+	include/alibabacloud/alb/model/EnableLoadBalancerAccessLogRequest.h
+	include/alibabacloud/alb/model/EnableLoadBalancerAccessLogResult.h
+	include/alibabacloud/alb/model/GetHealthCheckTemplateAttributeRequest.h
+	include/alibabacloud/alb/model/GetHealthCheckTemplateAttributeResult.h
+	include/alibabacloud/alb/model/GetListenerAttributeRequest.h
+	include/alibabacloud/alb/model/GetListenerAttributeResult.h
+	include/alibabacloud/alb/model/GetLoadBalancerAttributeRequest.h
+	include/alibabacloud/alb/model/GetLoadBalancerAttributeResult.h
+	include/alibabacloud/alb/model/ListAclEntriesRequest.h
+	include/alibabacloud/alb/model/ListAclEntriesResult.h
+	include/alibabacloud/alb/model/ListAclRelationsRequest.h
+	include/alibabacloud/alb/model/ListAclRelationsResult.h
+	include/alibabacloud/alb/model/ListAclsRequest.h
+	include/alibabacloud/alb/model/ListAclsResult.h
+	include/alibabacloud/alb/model/ListAsynJobsRequest.h
+	include/alibabacloud/alb/model/ListAsynJobsResult.h
+	include/alibabacloud/alb/model/ListHealthCheckTemplatesRequest.h
+	include/alibabacloud/alb/model/ListHealthCheckTemplatesResult.h
+	include/alibabacloud/alb/model/ListListenerCertificatesRequest.h
+	include/alibabacloud/alb/model/ListListenerCertificatesResult.h
+	include/alibabacloud/alb/model/ListListenersRequest.h
+	include/alibabacloud/alb/model/ListListenersResult.h
+	include/alibabacloud/alb/model/ListLoadBalancersRequest.h
+	include/alibabacloud/alb/model/ListLoadBalancersResult.h
+	include/alibabacloud/alb/model/ListRulesRequest.h
+	include/alibabacloud/alb/model/ListRulesResult.h
+	include/alibabacloud/alb/model/ListSecurityPoliciesRequest.h
+	include/alibabacloud/alb/model/ListSecurityPoliciesResult.h
+	include/alibabacloud/alb/model/ListSecurityPolicyRelationsRequest.h
+	include/alibabacloud/alb/model/ListSecurityPolicyRelationsResult.h
+	include/alibabacloud/alb/model/ListServerGroupServersRequest.h
+	include/alibabacloud/alb/model/ListServerGroupServersResult.h
+	include/alibabacloud/alb/model/ListServerGroupsRequest.h
+	include/alibabacloud/alb/model/ListServerGroupsResult.h
+	include/alibabacloud/alb/model/ListSystemSecurityPoliciesRequest.h
+	include/alibabacloud/alb/model/ListSystemSecurityPoliciesResult.h
+	include/alibabacloud/alb/model/ListTagKeysRequest.h
+	include/alibabacloud/alb/model/ListTagKeysResult.h
+	include/alibabacloud/alb/model/ListTagResourcesRequest.h
+	include/alibabacloud/alb/model/ListTagResourcesResult.h
+	include/alibabacloud/alb/model/ListTagValuesRequest.h
+	include/alibabacloud/alb/model/ListTagValuesResult.h
+	include/alibabacloud/alb/model/MoveResourceGroupRequest.h
+	include/alibabacloud/alb/model/MoveResourceGroupResult.h
+	include/alibabacloud/alb/model/RemoveEntriesFromAclRequest.h
+	include/alibabacloud/alb/model/RemoveEntriesFromAclResult.h
+	include/alibabacloud/alb/model/RemoveServersFromServerGroupRequest.h
+	include/alibabacloud/alb/model/RemoveServersFromServerGroupResult.h
+	include/alibabacloud/alb/model/ReplaceServersInServerGroupRequest.h
+	include/alibabacloud/alb/model/ReplaceServersInServerGroupResult.h
+	include/alibabacloud/alb/model/StartListenerRequest.h
+	include/alibabacloud/alb/model/StartListenerResult.h
+	include/alibabacloud/alb/model/StopListenerRequest.h
+	include/alibabacloud/alb/model/StopListenerResult.h
+	include/alibabacloud/alb/model/TagResourcesRequest.h
+	include/alibabacloud/alb/model/TagResourcesResult.h
+	include/alibabacloud/alb/model/UnTagResourcesRequest.h
+	include/alibabacloud/alb/model/UnTagResourcesResult.h
+	include/alibabacloud/alb/model/UpdateAclAttributeRequest.h
+	include/alibabacloud/alb/model/UpdateAclAttributeResult.h
+	include/alibabacloud/alb/model/UpdateHealthCheckTemplateAttributeRequest.h
+	include/alibabacloud/alb/model/UpdateHealthCheckTemplateAttributeResult.h
+	include/alibabacloud/alb/model/UpdateListenerAttributeRequest.h
+	include/alibabacloud/alb/model/UpdateListenerAttributeResult.h
+	include/alibabacloud/alb/model/UpdateListenerLogConfigRequest.h
+	include/alibabacloud/alb/model/UpdateListenerLogConfigResult.h
+	include/alibabacloud/alb/model/UpdateLoadBalancerAttributeRequest.h
+	include/alibabacloud/alb/model/UpdateLoadBalancerAttributeResult.h
+	include/alibabacloud/alb/model/UpdateLoadBalancerEditionRequest.h
+	include/alibabacloud/alb/model/UpdateLoadBalancerEditionResult.h
+	include/alibabacloud/alb/model/UpdateRuleAttributeRequest.h
+	include/alibabacloud/alb/model/UpdateRuleAttributeResult.h
+	include/alibabacloud/alb/model/UpdateRulesAttributeRequest.h
+	include/alibabacloud/alb/model/UpdateRulesAttributeResult.h
+	include/alibabacloud/alb/model/UpdateSecurityPolicyAttributeRequest.h
+	include/alibabacloud/alb/model/UpdateSecurityPolicyAttributeResult.h
+	include/alibabacloud/alb/model/UpdateServerGroupAttributeRequest.h
+	include/alibabacloud/alb/model/UpdateServerGroupAttributeResult.h
+	include/alibabacloud/alb/model/UpdateServerGroupServersAttributeRequest.h
+	include/alibabacloud/alb/model/UpdateServerGroupServersAttributeResult.h )
+
+set(alb_src 
+	src/AlbClient.cc
+	src/model/AddEntriesToAclRequest.cc
+	src/model/AddEntriesToAclResult.cc
+	src/model/AddServersToServerGroupRequest.cc
+	src/model/AddServersToServerGroupResult.cc
+	src/model/AssociateAclsWithListenerRequest.cc
+	src/model/AssociateAclsWithListenerResult.cc
+	src/model/AssociateAdditionalCertificatesWithListenerRequest.cc
+	src/model/AssociateAdditionalCertificatesWithListenerResult.cc
+	src/model/CreateAclRequest.cc
+	src/model/CreateAclResult.cc
+	src/model/CreateHealthCheckTemplateRequest.cc
+	src/model/CreateHealthCheckTemplateResult.cc
+	src/model/CreateListenerRequest.cc
+	src/model/CreateListenerResult.cc
+	src/model/CreateLoadBalancerRequest.cc
+	src/model/CreateLoadBalancerResult.cc
+	src/model/CreateRuleRequest.cc
+	src/model/CreateRuleResult.cc
+	src/model/CreateRulesRequest.cc
+	src/model/CreateRulesResult.cc
+	src/model/CreateSecurityPolicyRequest.cc
+	src/model/CreateSecurityPolicyResult.cc
+	src/model/CreateServerGroupRequest.cc
+	src/model/CreateServerGroupResult.cc
+	src/model/DeleteAclRequest.cc
+	src/model/DeleteAclResult.cc
+	src/model/DeleteHealthCheckTemplatesRequest.cc
+	src/model/DeleteHealthCheckTemplatesResult.cc
+	src/model/DeleteListenerRequest.cc
+	src/model/DeleteListenerResult.cc
+	src/model/DeleteLoadBalancerRequest.cc
+	src/model/DeleteLoadBalancerResult.cc
+	src/model/DeleteRuleRequest.cc
+	src/model/DeleteRuleResult.cc
+	src/model/DeleteRulesRequest.cc
+	src/model/DeleteRulesResult.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/DisableDeletionProtectionRequest.cc
+	src/model/DisableDeletionProtectionResult.cc
+	src/model/DisableLoadBalancerAccessLogRequest.cc
+	src/model/DisableLoadBalancerAccessLogResult.cc
+	src/model/DissociateAclsFromListenerRequest.cc
+	src/model/DissociateAclsFromListenerResult.cc
+	src/model/DissociateAdditionalCertificatesFromListenerRequest.cc
+	src/model/DissociateAdditionalCertificatesFromListenerResult.cc
+	src/model/EnableDeletionProtectionRequest.cc
+	src/model/EnableDeletionProtectionResult.cc
+	src/model/EnableLoadBalancerAccessLogRequest.cc
+	src/model/EnableLoadBalancerAccessLogResult.cc
+	src/model/GetHealthCheckTemplateAttributeRequest.cc
+	src/model/GetHealthCheckTemplateAttributeResult.cc
+	src/model/GetListenerAttributeRequest.cc
+	src/model/GetListenerAttributeResult.cc
+	src/model/GetLoadBalancerAttributeRequest.cc
+	src/model/GetLoadBalancerAttributeResult.cc
+	src/model/ListAclEntriesRequest.cc
+	src/model/ListAclEntriesResult.cc
+	src/model/ListAclRelationsRequest.cc
+	src/model/ListAclRelationsResult.cc
+	src/model/ListAclsRequest.cc
+	src/model/ListAclsResult.cc
+	src/model/ListAsynJobsRequest.cc
+	src/model/ListAsynJobsResult.cc
+	src/model/ListHealthCheckTemplatesRequest.cc
+	src/model/ListHealthCheckTemplatesResult.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/ListRulesRequest.cc
+	src/model/ListRulesResult.cc
+	src/model/ListSecurityPoliciesRequest.cc
+	src/model/ListSecurityPoliciesResult.cc
+	src/model/ListSecurityPolicyRelationsRequest.cc
+	src/model/ListSecurityPolicyRelationsResult.cc
+	src/model/ListServerGroupServersRequest.cc
+	src/model/ListServerGroupServersResult.cc
+	src/model/ListServerGroupsRequest.cc
+	src/model/ListServerGroupsResult.cc
+	src/model/ListSystemSecurityPoliciesRequest.cc
+	src/model/ListSystemSecurityPoliciesResult.cc
+	src/model/ListTagKeysRequest.cc
+	src/model/ListTagKeysResult.cc
+	src/model/ListTagResourcesRequest.cc
+	src/model/ListTagResourcesResult.cc
+	src/model/ListTagValuesRequest.cc
+	src/model/ListTagValuesResult.cc
+	src/model/MoveResourceGroupRequest.cc
+	src/model/MoveResourceGroupResult.cc
+	src/model/RemoveEntriesFromAclRequest.cc
+	src/model/RemoveEntriesFromAclResult.cc
+	src/model/RemoveServersFromServerGroupRequest.cc
+	src/model/RemoveServersFromServerGroupResult.cc
+	src/model/ReplaceServersInServerGroupRequest.cc
+	src/model/ReplaceServersInServerGroupResult.cc
+	src/model/StartListenerRequest.cc
+	src/model/StartListenerResult.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/UpdateAclAttributeRequest.cc
+	src/model/UpdateAclAttributeResult.cc
+	src/model/UpdateHealthCheckTemplateAttributeRequest.cc
+	src/model/UpdateHealthCheckTemplateAttributeResult.cc
+	src/model/UpdateListenerAttributeRequest.cc
+	src/model/UpdateListenerAttributeResult.cc
+	src/model/UpdateListenerLogConfigRequest.cc
+	src/model/UpdateListenerLogConfigResult.cc
+	src/model/UpdateLoadBalancerAttributeRequest.cc
+	src/model/UpdateLoadBalancerAttributeResult.cc
+	src/model/UpdateLoadBalancerEditionRequest.cc
+	src/model/UpdateLoadBalancerEditionResult.cc
+	src/model/UpdateRuleAttributeRequest.cc
+	src/model/UpdateRuleAttributeResult.cc
+	src/model/UpdateRulesAttributeRequest.cc
+	src/model/UpdateRulesAttributeResult.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(alb ${LIB_TYPE}
+	${alb_public_header}
+	${alb_public_header_model}
+	${alb_src})
+
+set_target_properties(alb
+	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}alb
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(alb
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_ALB_LIBRARY)
+endif()
+
+target_include_directories(alb
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(alb
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(alb
+		jsoncpp)
+	target_include_directories(alb
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(alb
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(alb
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(alb
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(alb
+		jsoncpp)
+endif()
+
+install(FILES ${alb_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/alb)
+install(FILES ${alb_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/alb/model)
+install(TARGETS alb
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

alb/include/alibabacloud/alb/AlbClient.h

@@ -0,0 +1,582 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_ALBCLIENT_H_
+#define ALIBABACLOUD_ALB_ALBCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "AlbExport.h"
+#include "model/AddEntriesToAclRequest.h"
+#include "model/AddEntriesToAclResult.h"
+#include "model/AddServersToServerGroupRequest.h"
+#include "model/AddServersToServerGroupResult.h"
+#include "model/AssociateAclsWithListenerRequest.h"
+#include "model/AssociateAclsWithListenerResult.h"
+#include "model/AssociateAdditionalCertificatesWithListenerRequest.h"
+#include "model/AssociateAdditionalCertificatesWithListenerResult.h"
+#include "model/CreateAclRequest.h"
+#include "model/CreateAclResult.h"
+#include "model/CreateHealthCheckTemplateRequest.h"
+#include "model/CreateHealthCheckTemplateResult.h"
+#include "model/CreateListenerRequest.h"
+#include "model/CreateListenerResult.h"
+#include "model/CreateLoadBalancerRequest.h"
+#include "model/CreateLoadBalancerResult.h"
+#include "model/CreateRuleRequest.h"
+#include "model/CreateRuleResult.h"
+#include "model/CreateRulesRequest.h"
+#include "model/CreateRulesResult.h"
+#include "model/CreateSecurityPolicyRequest.h"
+#include "model/CreateSecurityPolicyResult.h"
+#include "model/CreateServerGroupRequest.h"
+#include "model/CreateServerGroupResult.h"
+#include "model/DeleteAclRequest.h"
+#include "model/DeleteAclResult.h"
+#include "model/DeleteHealthCheckTemplatesRequest.h"
+#include "model/DeleteHealthCheckTemplatesResult.h"
+#include "model/DeleteListenerRequest.h"
+#include "model/DeleteListenerResult.h"
+#include "model/DeleteLoadBalancerRequest.h"
+#include "model/DeleteLoadBalancerResult.h"
+#include "model/DeleteRuleRequest.h"
+#include "model/DeleteRuleResult.h"
+#include "model/DeleteRulesRequest.h"
+#include "model/DeleteRulesResult.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/DisableDeletionProtectionRequest.h"
+#include "model/DisableDeletionProtectionResult.h"
+#include "model/DisableLoadBalancerAccessLogRequest.h"
+#include "model/DisableLoadBalancerAccessLogResult.h"
+#include "model/DissociateAclsFromListenerRequest.h"
+#include "model/DissociateAclsFromListenerResult.h"
+#include "model/DissociateAdditionalCertificatesFromListenerRequest.h"
+#include "model/DissociateAdditionalCertificatesFromListenerResult.h"
+#include "model/EnableDeletionProtectionRequest.h"
+#include "model/EnableDeletionProtectionResult.h"
+#include "model/EnableLoadBalancerAccessLogRequest.h"
+#include "model/EnableLoadBalancerAccessLogResult.h"
+#include "model/GetHealthCheckTemplateAttributeRequest.h"
+#include "model/GetHealthCheckTemplateAttributeResult.h"
+#include "model/GetListenerAttributeRequest.h"
+#include "model/GetListenerAttributeResult.h"
+#include "model/GetLoadBalancerAttributeRequest.h"
+#include "model/GetLoadBalancerAttributeResult.h"
+#include "model/ListAclEntriesRequest.h"
+#include "model/ListAclEntriesResult.h"
+#include "model/ListAclRelationsRequest.h"
+#include "model/ListAclRelationsResult.h"
+#include "model/ListAclsRequest.h"
+#include "model/ListAclsResult.h"
+#include "model/ListAsynJobsRequest.h"
+#include "model/ListAsynJobsResult.h"
+#include "model/ListHealthCheckTemplatesRequest.h"
+#include "model/ListHealthCheckTemplatesResult.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/ListRulesRequest.h"
+#include "model/ListRulesResult.h"
+#include "model/ListSecurityPoliciesRequest.h"
+#include "model/ListSecurityPoliciesResult.h"
+#include "model/ListSecurityPolicyRelationsRequest.h"
+#include "model/ListSecurityPolicyRelationsResult.h"
+#include "model/ListServerGroupServersRequest.h"
+#include "model/ListServerGroupServersResult.h"
+#include "model/ListServerGroupsRequest.h"
+#include "model/ListServerGroupsResult.h"
+#include "model/ListSystemSecurityPoliciesRequest.h"
+#include "model/ListSystemSecurityPoliciesResult.h"
+#include "model/ListTagKeysRequest.h"
+#include "model/ListTagKeysResult.h"
+#include "model/ListTagResourcesRequest.h"
+#include "model/ListTagResourcesResult.h"
+#include "model/ListTagValuesRequest.h"
+#include "model/ListTagValuesResult.h"
+#include "model/MoveResourceGroupRequest.h"
+#include "model/MoveResourceGroupResult.h"
+#include "model/RemoveEntriesFromAclRequest.h"
+#include "model/RemoveEntriesFromAclResult.h"
+#include "model/RemoveServersFromServerGroupRequest.h"
+#include "model/RemoveServersFromServerGroupResult.h"
+#include "model/ReplaceServersInServerGroupRequest.h"
+#include "model/ReplaceServersInServerGroupResult.h"
+#include "model/StartListenerRequest.h"
+#include "model/StartListenerResult.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/UpdateAclAttributeRequest.h"
+#include "model/UpdateAclAttributeResult.h"
+#include "model/UpdateHealthCheckTemplateAttributeRequest.h"
+#include "model/UpdateHealthCheckTemplateAttributeResult.h"
+#include "model/UpdateListenerAttributeRequest.h"
+#include "model/UpdateListenerAttributeResult.h"
+#include "model/UpdateListenerLogConfigRequest.h"
+#include "model/UpdateListenerLogConfigResult.h"
+#include "model/UpdateLoadBalancerAttributeRequest.h"
+#include "model/UpdateLoadBalancerAttributeResult.h"
+#include "model/UpdateLoadBalancerEditionRequest.h"
+#include "model/UpdateLoadBalancerEditionResult.h"
+#include "model/UpdateRuleAttributeRequest.h"
+#include "model/UpdateRuleAttributeResult.h"
+#include "model/UpdateRulesAttributeRequest.h"
+#include "model/UpdateRulesAttributeResult.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 Alb
+	{
+		class ALIBABACLOUD_ALB_EXPORT AlbClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::AddEntriesToAclResult> AddEntriesToAclOutcome;
+			typedef std::future<AddEntriesToAclOutcome> AddEntriesToAclOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::AddEntriesToAclRequest&, const AddEntriesToAclOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddEntriesToAclAsyncHandler;
+			typedef Outcome<Error, Model::AddServersToServerGroupResult> AddServersToServerGroupOutcome;
+			typedef std::future<AddServersToServerGroupOutcome> AddServersToServerGroupOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::AddServersToServerGroupRequest&, const AddServersToServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddServersToServerGroupAsyncHandler;
+			typedef Outcome<Error, Model::AssociateAclsWithListenerResult> AssociateAclsWithListenerOutcome;
+			typedef std::future<AssociateAclsWithListenerOutcome> AssociateAclsWithListenerOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::AssociateAclsWithListenerRequest&, const AssociateAclsWithListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssociateAclsWithListenerAsyncHandler;
+			typedef Outcome<Error, Model::AssociateAdditionalCertificatesWithListenerResult> AssociateAdditionalCertificatesWithListenerOutcome;
+			typedef std::future<AssociateAdditionalCertificatesWithListenerOutcome> AssociateAdditionalCertificatesWithListenerOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::AssociateAdditionalCertificatesWithListenerRequest&, const AssociateAdditionalCertificatesWithListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssociateAdditionalCertificatesWithListenerAsyncHandler;
+			typedef Outcome<Error, Model::CreateAclResult> CreateAclOutcome;
+			typedef std::future<CreateAclOutcome> CreateAclOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::CreateAclRequest&, const CreateAclOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAclAsyncHandler;
+			typedef Outcome<Error, Model::CreateHealthCheckTemplateResult> CreateHealthCheckTemplateOutcome;
+			typedef std::future<CreateHealthCheckTemplateOutcome> CreateHealthCheckTemplateOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::CreateHealthCheckTemplateRequest&, const CreateHealthCheckTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateHealthCheckTemplateAsyncHandler;
+			typedef Outcome<Error, Model::CreateListenerResult> CreateListenerOutcome;
+			typedef std::future<CreateListenerOutcome> CreateListenerOutcomeCallable;
+			typedef std::function<void(const AlbClient*, 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 AlbClient*, const Model::CreateLoadBalancerRequest&, const CreateLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLoadBalancerAsyncHandler;
+			typedef Outcome<Error, Model::CreateRuleResult> CreateRuleOutcome;
+			typedef std::future<CreateRuleOutcome> CreateRuleOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::CreateRuleRequest&, const CreateRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRuleAsyncHandler;
+			typedef Outcome<Error, Model::CreateRulesResult> CreateRulesOutcome;
+			typedef std::future<CreateRulesOutcome> CreateRulesOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::CreateRulesRequest&, const CreateRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRulesAsyncHandler;
+			typedef Outcome<Error, Model::CreateSecurityPolicyResult> CreateSecurityPolicyOutcome;
+			typedef std::future<CreateSecurityPolicyOutcome> CreateSecurityPolicyOutcomeCallable;
+			typedef std::function<void(const AlbClient*, 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 AlbClient*, const Model::CreateServerGroupRequest&, const CreateServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateServerGroupAsyncHandler;
+			typedef Outcome<Error, Model::DeleteAclResult> DeleteAclOutcome;
+			typedef std::future<DeleteAclOutcome> DeleteAclOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::DeleteAclRequest&, const DeleteAclOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAclAsyncHandler;
+			typedef Outcome<Error, Model::DeleteHealthCheckTemplatesResult> DeleteHealthCheckTemplatesOutcome;
+			typedef std::future<DeleteHealthCheckTemplatesOutcome> DeleteHealthCheckTemplatesOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::DeleteHealthCheckTemplatesRequest&, const DeleteHealthCheckTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteHealthCheckTemplatesAsyncHandler;
+			typedef Outcome<Error, Model::DeleteListenerResult> DeleteListenerOutcome;
+			typedef std::future<DeleteListenerOutcome> DeleteListenerOutcomeCallable;
+			typedef std::function<void(const AlbClient*, 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 AlbClient*, const Model::DeleteLoadBalancerRequest&, const DeleteLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLoadBalancerAsyncHandler;
+			typedef Outcome<Error, Model::DeleteRuleResult> DeleteRuleOutcome;
+			typedef std::future<DeleteRuleOutcome> DeleteRuleOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::DeleteRuleRequest&, const DeleteRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteRuleAsyncHandler;
+			typedef Outcome<Error, Model::DeleteRulesResult> DeleteRulesOutcome;
+			typedef std::future<DeleteRulesOutcome> DeleteRulesOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::DeleteRulesRequest&, const DeleteRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteRulesAsyncHandler;
+			typedef Outcome<Error, Model::DeleteSecurityPolicyResult> DeleteSecurityPolicyOutcome;
+			typedef std::future<DeleteSecurityPolicyOutcome> DeleteSecurityPolicyOutcomeCallable;
+			typedef std::function<void(const AlbClient*, 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 AlbClient*, 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 AlbClient*, 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 AlbClient*, const Model::DescribeZonesRequest&, const DescribeZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeZonesAsyncHandler;
+			typedef Outcome<Error, Model::DisableDeletionProtectionResult> DisableDeletionProtectionOutcome;
+			typedef std::future<DisableDeletionProtectionOutcome> DisableDeletionProtectionOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::DisableDeletionProtectionRequest&, const DisableDeletionProtectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableDeletionProtectionAsyncHandler;
+			typedef Outcome<Error, Model::DisableLoadBalancerAccessLogResult> DisableLoadBalancerAccessLogOutcome;
+			typedef std::future<DisableLoadBalancerAccessLogOutcome> DisableLoadBalancerAccessLogOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::DisableLoadBalancerAccessLogRequest&, const DisableLoadBalancerAccessLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableLoadBalancerAccessLogAsyncHandler;
+			typedef Outcome<Error, Model::DissociateAclsFromListenerResult> DissociateAclsFromListenerOutcome;
+			typedef std::future<DissociateAclsFromListenerOutcome> DissociateAclsFromListenerOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::DissociateAclsFromListenerRequest&, const DissociateAclsFromListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DissociateAclsFromListenerAsyncHandler;
+			typedef Outcome<Error, Model::DissociateAdditionalCertificatesFromListenerResult> DissociateAdditionalCertificatesFromListenerOutcome;
+			typedef std::future<DissociateAdditionalCertificatesFromListenerOutcome> DissociateAdditionalCertificatesFromListenerOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::DissociateAdditionalCertificatesFromListenerRequest&, const DissociateAdditionalCertificatesFromListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DissociateAdditionalCertificatesFromListenerAsyncHandler;
+			typedef Outcome<Error, Model::EnableDeletionProtectionResult> EnableDeletionProtectionOutcome;
+			typedef std::future<EnableDeletionProtectionOutcome> EnableDeletionProtectionOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::EnableDeletionProtectionRequest&, const EnableDeletionProtectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableDeletionProtectionAsyncHandler;
+			typedef Outcome<Error, Model::EnableLoadBalancerAccessLogResult> EnableLoadBalancerAccessLogOutcome;
+			typedef std::future<EnableLoadBalancerAccessLogOutcome> EnableLoadBalancerAccessLogOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::EnableLoadBalancerAccessLogRequest&, const EnableLoadBalancerAccessLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableLoadBalancerAccessLogAsyncHandler;
+			typedef Outcome<Error, Model::GetHealthCheckTemplateAttributeResult> GetHealthCheckTemplateAttributeOutcome;
+			typedef std::future<GetHealthCheckTemplateAttributeOutcome> GetHealthCheckTemplateAttributeOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::GetHealthCheckTemplateAttributeRequest&, const GetHealthCheckTemplateAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetHealthCheckTemplateAttributeAsyncHandler;
+			typedef Outcome<Error, Model::GetListenerAttributeResult> GetListenerAttributeOutcome;
+			typedef std::future<GetListenerAttributeOutcome> GetListenerAttributeOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::GetListenerAttributeRequest&, const GetListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetListenerAttributeAsyncHandler;
+			typedef Outcome<Error, Model::GetLoadBalancerAttributeResult> GetLoadBalancerAttributeOutcome;
+			typedef std::future<GetLoadBalancerAttributeOutcome> GetLoadBalancerAttributeOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::GetLoadBalancerAttributeRequest&, const GetLoadBalancerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLoadBalancerAttributeAsyncHandler;
+			typedef Outcome<Error, Model::ListAclEntriesResult> ListAclEntriesOutcome;
+			typedef std::future<ListAclEntriesOutcome> ListAclEntriesOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::ListAclEntriesRequest&, const ListAclEntriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAclEntriesAsyncHandler;
+			typedef Outcome<Error, Model::ListAclRelationsResult> ListAclRelationsOutcome;
+			typedef std::future<ListAclRelationsOutcome> ListAclRelationsOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::ListAclRelationsRequest&, const ListAclRelationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAclRelationsAsyncHandler;
+			typedef Outcome<Error, Model::ListAclsResult> ListAclsOutcome;
+			typedef std::future<ListAclsOutcome> ListAclsOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::ListAclsRequest&, const ListAclsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAclsAsyncHandler;
+			typedef Outcome<Error, Model::ListAsynJobsResult> ListAsynJobsOutcome;
+			typedef std::future<ListAsynJobsOutcome> ListAsynJobsOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::ListAsynJobsRequest&, const ListAsynJobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAsynJobsAsyncHandler;
+			typedef Outcome<Error, Model::ListHealthCheckTemplatesResult> ListHealthCheckTemplatesOutcome;
+			typedef std::future<ListHealthCheckTemplatesOutcome> ListHealthCheckTemplatesOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::ListHealthCheckTemplatesRequest&, const ListHealthCheckTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListHealthCheckTemplatesAsyncHandler;
+			typedef Outcome<Error, Model::ListListenerCertificatesResult> ListListenerCertificatesOutcome;
+			typedef std::future<ListListenerCertificatesOutcome> ListListenerCertificatesOutcomeCallable;
+			typedef std::function<void(const AlbClient*, 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 AlbClient*, 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 AlbClient*, const Model::ListLoadBalancersRequest&, const ListLoadBalancersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListLoadBalancersAsyncHandler;
+			typedef Outcome<Error, Model::ListRulesResult> ListRulesOutcome;
+			typedef std::future<ListRulesOutcome> ListRulesOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::ListRulesRequest&, const ListRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListRulesAsyncHandler;
+			typedef Outcome<Error, Model::ListSecurityPoliciesResult> ListSecurityPoliciesOutcome;
+			typedef std::future<ListSecurityPoliciesOutcome> ListSecurityPoliciesOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::ListSecurityPoliciesRequest&, const ListSecurityPoliciesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSecurityPoliciesAsyncHandler;
+			typedef Outcome<Error, Model::ListSecurityPolicyRelationsResult> ListSecurityPolicyRelationsOutcome;
+			typedef std::future<ListSecurityPolicyRelationsOutcome> ListSecurityPolicyRelationsOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::ListSecurityPolicyRelationsRequest&, const ListSecurityPolicyRelationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSecurityPolicyRelationsAsyncHandler;
+			typedef Outcome<Error, Model::ListServerGroupServersResult> ListServerGroupServersOutcome;
+			typedef std::future<ListServerGroupServersOutcome> ListServerGroupServersOutcomeCallable;
+			typedef std::function<void(const AlbClient*, 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 AlbClient*, const Model::ListServerGroupsRequest&, const ListServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListServerGroupsAsyncHandler;
+			typedef Outcome<Error, Model::ListSystemSecurityPoliciesResult> ListSystemSecurityPoliciesOutcome;
+			typedef std::future<ListSystemSecurityPoliciesOutcome> ListSystemSecurityPoliciesOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::ListSystemSecurityPoliciesRequest&, const ListSystemSecurityPoliciesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSystemSecurityPoliciesAsyncHandler;
+			typedef Outcome<Error, Model::ListTagKeysResult> ListTagKeysOutcome;
+			typedef std::future<ListTagKeysOutcome> ListTagKeysOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::ListTagKeysRequest&, const ListTagKeysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagKeysAsyncHandler;
+			typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
+			typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
+			typedef Outcome<Error, Model::ListTagValuesResult> ListTagValuesOutcome;
+			typedef std::future<ListTagValuesOutcome> ListTagValuesOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::ListTagValuesRequest&, const ListTagValuesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagValuesAsyncHandler;
+			typedef Outcome<Error, Model::MoveResourceGroupResult> MoveResourceGroupOutcome;
+			typedef std::future<MoveResourceGroupOutcome> MoveResourceGroupOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::MoveResourceGroupRequest&, const MoveResourceGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoveResourceGroupAsyncHandler;
+			typedef Outcome<Error, Model::RemoveEntriesFromAclResult> RemoveEntriesFromAclOutcome;
+			typedef std::future<RemoveEntriesFromAclOutcome> RemoveEntriesFromAclOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::RemoveEntriesFromAclRequest&, const RemoveEntriesFromAclOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveEntriesFromAclAsyncHandler;
+			typedef Outcome<Error, Model::RemoveServersFromServerGroupResult> RemoveServersFromServerGroupOutcome;
+			typedef std::future<RemoveServersFromServerGroupOutcome> RemoveServersFromServerGroupOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::RemoveServersFromServerGroupRequest&, const RemoveServersFromServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveServersFromServerGroupAsyncHandler;
+			typedef Outcome<Error, Model::ReplaceServersInServerGroupResult> ReplaceServersInServerGroupOutcome;
+			typedef std::future<ReplaceServersInServerGroupOutcome> ReplaceServersInServerGroupOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::ReplaceServersInServerGroupRequest&, const ReplaceServersInServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReplaceServersInServerGroupAsyncHandler;
+			typedef Outcome<Error, Model::StartListenerResult> StartListenerOutcome;
+			typedef std::future<StartListenerOutcome> StartListenerOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::StartListenerRequest&, const StartListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartListenerAsyncHandler;
+			typedef Outcome<Error, Model::StopListenerResult> StopListenerOutcome;
+			typedef std::future<StopListenerOutcome> StopListenerOutcomeCallable;
+			typedef std::function<void(const AlbClient*, 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 AlbClient*, 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 AlbClient*, const Model::UnTagResourcesRequest&, const UnTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnTagResourcesAsyncHandler;
+			typedef Outcome<Error, Model::UpdateAclAttributeResult> UpdateAclAttributeOutcome;
+			typedef std::future<UpdateAclAttributeOutcome> UpdateAclAttributeOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::UpdateAclAttributeRequest&, const UpdateAclAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAclAttributeAsyncHandler;
+			typedef Outcome<Error, Model::UpdateHealthCheckTemplateAttributeResult> UpdateHealthCheckTemplateAttributeOutcome;
+			typedef std::future<UpdateHealthCheckTemplateAttributeOutcome> UpdateHealthCheckTemplateAttributeOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::UpdateHealthCheckTemplateAttributeRequest&, const UpdateHealthCheckTemplateAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateHealthCheckTemplateAttributeAsyncHandler;
+			typedef Outcome<Error, Model::UpdateListenerAttributeResult> UpdateListenerAttributeOutcome;
+			typedef std::future<UpdateListenerAttributeOutcome> UpdateListenerAttributeOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::UpdateListenerAttributeRequest&, const UpdateListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateListenerAttributeAsyncHandler;
+			typedef Outcome<Error, Model::UpdateListenerLogConfigResult> UpdateListenerLogConfigOutcome;
+			typedef std::future<UpdateListenerLogConfigOutcome> UpdateListenerLogConfigOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::UpdateListenerLogConfigRequest&, const UpdateListenerLogConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateListenerLogConfigAsyncHandler;
+			typedef Outcome<Error, Model::UpdateLoadBalancerAttributeResult> UpdateLoadBalancerAttributeOutcome;
+			typedef std::future<UpdateLoadBalancerAttributeOutcome> UpdateLoadBalancerAttributeOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::UpdateLoadBalancerAttributeRequest&, const UpdateLoadBalancerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLoadBalancerAttributeAsyncHandler;
+			typedef Outcome<Error, Model::UpdateLoadBalancerEditionResult> UpdateLoadBalancerEditionOutcome;
+			typedef std::future<UpdateLoadBalancerEditionOutcome> UpdateLoadBalancerEditionOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::UpdateLoadBalancerEditionRequest&, const UpdateLoadBalancerEditionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLoadBalancerEditionAsyncHandler;
+			typedef Outcome<Error, Model::UpdateRuleAttributeResult> UpdateRuleAttributeOutcome;
+			typedef std::future<UpdateRuleAttributeOutcome> UpdateRuleAttributeOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::UpdateRuleAttributeRequest&, const UpdateRuleAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateRuleAttributeAsyncHandler;
+			typedef Outcome<Error, Model::UpdateRulesAttributeResult> UpdateRulesAttributeOutcome;
+			typedef std::future<UpdateRulesAttributeOutcome> UpdateRulesAttributeOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::UpdateRulesAttributeRequest&, const UpdateRulesAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateRulesAttributeAsyncHandler;
+			typedef Outcome<Error, Model::UpdateSecurityPolicyAttributeResult> UpdateSecurityPolicyAttributeOutcome;
+			typedef std::future<UpdateSecurityPolicyAttributeOutcome> UpdateSecurityPolicyAttributeOutcomeCallable;
+			typedef std::function<void(const AlbClient*, 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 AlbClient*, 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 AlbClient*, const Model::UpdateServerGroupServersAttributeRequest&, const UpdateServerGroupServersAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateServerGroupServersAttributeAsyncHandler;
+
+			AlbClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			AlbClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			AlbClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~AlbClient();
+			AddEntriesToAclOutcome addEntriesToAcl(const Model::AddEntriesToAclRequest &request)const;
+			void addEntriesToAclAsync(const Model::AddEntriesToAclRequest& request, const AddEntriesToAclAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddEntriesToAclOutcomeCallable addEntriesToAclCallable(const Model::AddEntriesToAclRequest& request) const;
+			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;
+			AssociateAclsWithListenerOutcome associateAclsWithListener(const Model::AssociateAclsWithListenerRequest &request)const;
+			void associateAclsWithListenerAsync(const Model::AssociateAclsWithListenerRequest& request, const AssociateAclsWithListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AssociateAclsWithListenerOutcomeCallable associateAclsWithListenerCallable(const Model::AssociateAclsWithListenerRequest& 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;
+			CreateAclOutcome createAcl(const Model::CreateAclRequest &request)const;
+			void createAclAsync(const Model::CreateAclRequest& request, const CreateAclAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateAclOutcomeCallable createAclCallable(const Model::CreateAclRequest& request) const;
+			CreateHealthCheckTemplateOutcome createHealthCheckTemplate(const Model::CreateHealthCheckTemplateRequest &request)const;
+			void createHealthCheckTemplateAsync(const Model::CreateHealthCheckTemplateRequest& request, const CreateHealthCheckTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateHealthCheckTemplateOutcomeCallable createHealthCheckTemplateCallable(const Model::CreateHealthCheckTemplateRequest& 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;
+			CreateRuleOutcome createRule(const Model::CreateRuleRequest &request)const;
+			void createRuleAsync(const Model::CreateRuleRequest& request, const CreateRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateRuleOutcomeCallable createRuleCallable(const Model::CreateRuleRequest& request) const;
+			CreateRulesOutcome createRules(const Model::CreateRulesRequest &request)const;
+			void createRulesAsync(const Model::CreateRulesRequest& request, const CreateRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateRulesOutcomeCallable createRulesCallable(const Model::CreateRulesRequest& 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;
+			DeleteAclOutcome deleteAcl(const Model::DeleteAclRequest &request)const;
+			void deleteAclAsync(const Model::DeleteAclRequest& request, const DeleteAclAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteAclOutcomeCallable deleteAclCallable(const Model::DeleteAclRequest& request) const;
+			DeleteHealthCheckTemplatesOutcome deleteHealthCheckTemplates(const Model::DeleteHealthCheckTemplatesRequest &request)const;
+			void deleteHealthCheckTemplatesAsync(const Model::DeleteHealthCheckTemplatesRequest& request, const DeleteHealthCheckTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteHealthCheckTemplatesOutcomeCallable deleteHealthCheckTemplatesCallable(const Model::DeleteHealthCheckTemplatesRequest& 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;
+			DeleteRuleOutcome deleteRule(const Model::DeleteRuleRequest &request)const;
+			void deleteRuleAsync(const Model::DeleteRuleRequest& request, const DeleteRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteRuleOutcomeCallable deleteRuleCallable(const Model::DeleteRuleRequest& request) const;
+			DeleteRulesOutcome deleteRules(const Model::DeleteRulesRequest &request)const;
+			void deleteRulesAsync(const Model::DeleteRulesRequest& request, const DeleteRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteRulesOutcomeCallable deleteRulesCallable(const Model::DeleteRulesRequest& 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;
+			DisableDeletionProtectionOutcome disableDeletionProtection(const Model::DisableDeletionProtectionRequest &request)const;
+			void disableDeletionProtectionAsync(const Model::DisableDeletionProtectionRequest& request, const DisableDeletionProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisableDeletionProtectionOutcomeCallable disableDeletionProtectionCallable(const Model::DisableDeletionProtectionRequest& request) const;
+			DisableLoadBalancerAccessLogOutcome disableLoadBalancerAccessLog(const Model::DisableLoadBalancerAccessLogRequest &request)const;
+			void disableLoadBalancerAccessLogAsync(const Model::DisableLoadBalancerAccessLogRequest& request, const DisableLoadBalancerAccessLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisableLoadBalancerAccessLogOutcomeCallable disableLoadBalancerAccessLogCallable(const Model::DisableLoadBalancerAccessLogRequest& request) const;
+			DissociateAclsFromListenerOutcome dissociateAclsFromListener(const Model::DissociateAclsFromListenerRequest &request)const;
+			void dissociateAclsFromListenerAsync(const Model::DissociateAclsFromListenerRequest& request, const DissociateAclsFromListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DissociateAclsFromListenerOutcomeCallable dissociateAclsFromListenerCallable(const Model::DissociateAclsFromListenerRequest& request) const;
+			DissociateAdditionalCertificatesFromListenerOutcome dissociateAdditionalCertificatesFromListener(const Model::DissociateAdditionalCertificatesFromListenerRequest &request)const;
+			void dissociateAdditionalCertificatesFromListenerAsync(const Model::DissociateAdditionalCertificatesFromListenerRequest& request, const DissociateAdditionalCertificatesFromListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DissociateAdditionalCertificatesFromListenerOutcomeCallable dissociateAdditionalCertificatesFromListenerCallable(const Model::DissociateAdditionalCertificatesFromListenerRequest& request) const;
+			EnableDeletionProtectionOutcome enableDeletionProtection(const Model::EnableDeletionProtectionRequest &request)const;
+			void enableDeletionProtectionAsync(const Model::EnableDeletionProtectionRequest& request, const EnableDeletionProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableDeletionProtectionOutcomeCallable enableDeletionProtectionCallable(const Model::EnableDeletionProtectionRequest& request) const;
+			EnableLoadBalancerAccessLogOutcome enableLoadBalancerAccessLog(const Model::EnableLoadBalancerAccessLogRequest &request)const;
+			void enableLoadBalancerAccessLogAsync(const Model::EnableLoadBalancerAccessLogRequest& request, const EnableLoadBalancerAccessLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableLoadBalancerAccessLogOutcomeCallable enableLoadBalancerAccessLogCallable(const Model::EnableLoadBalancerAccessLogRequest& request) const;
+			GetHealthCheckTemplateAttributeOutcome getHealthCheckTemplateAttribute(const Model::GetHealthCheckTemplateAttributeRequest &request)const;
+			void getHealthCheckTemplateAttributeAsync(const Model::GetHealthCheckTemplateAttributeRequest& request, const GetHealthCheckTemplateAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetHealthCheckTemplateAttributeOutcomeCallable getHealthCheckTemplateAttributeCallable(const Model::GetHealthCheckTemplateAttributeRequest& 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;
+			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;
+			ListAclEntriesOutcome listAclEntries(const Model::ListAclEntriesRequest &request)const;
+			void listAclEntriesAsync(const Model::ListAclEntriesRequest& request, const ListAclEntriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAclEntriesOutcomeCallable listAclEntriesCallable(const Model::ListAclEntriesRequest& request) const;
+			ListAclRelationsOutcome listAclRelations(const Model::ListAclRelationsRequest &request)const;
+			void listAclRelationsAsync(const Model::ListAclRelationsRequest& request, const ListAclRelationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAclRelationsOutcomeCallable listAclRelationsCallable(const Model::ListAclRelationsRequest& request) const;
+			ListAclsOutcome listAcls(const Model::ListAclsRequest &request)const;
+			void listAclsAsync(const Model::ListAclsRequest& request, const ListAclsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAclsOutcomeCallable listAclsCallable(const Model::ListAclsRequest& request) const;
+			ListAsynJobsOutcome listAsynJobs(const Model::ListAsynJobsRequest &request)const;
+			void listAsynJobsAsync(const Model::ListAsynJobsRequest& request, const ListAsynJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAsynJobsOutcomeCallable listAsynJobsCallable(const Model::ListAsynJobsRequest& request) const;
+			ListHealthCheckTemplatesOutcome listHealthCheckTemplates(const Model::ListHealthCheckTemplatesRequest &request)const;
+			void listHealthCheckTemplatesAsync(const Model::ListHealthCheckTemplatesRequest& request, const ListHealthCheckTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListHealthCheckTemplatesOutcomeCallable listHealthCheckTemplatesCallable(const Model::ListHealthCheckTemplatesRequest& 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;
+			ListRulesOutcome listRules(const Model::ListRulesRequest &request)const;
+			void listRulesAsync(const Model::ListRulesRequest& request, const ListRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListRulesOutcomeCallable listRulesCallable(const Model::ListRulesRequest& request) const;
+			ListSecurityPoliciesOutcome listSecurityPolicies(const Model::ListSecurityPoliciesRequest &request)const;
+			void listSecurityPoliciesAsync(const Model::ListSecurityPoliciesRequest& request, const ListSecurityPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSecurityPoliciesOutcomeCallable listSecurityPoliciesCallable(const Model::ListSecurityPoliciesRequest& request) const;
+			ListSecurityPolicyRelationsOutcome listSecurityPolicyRelations(const Model::ListSecurityPolicyRelationsRequest &request)const;
+			void listSecurityPolicyRelationsAsync(const Model::ListSecurityPolicyRelationsRequest& request, const ListSecurityPolicyRelationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSecurityPolicyRelationsOutcomeCallable listSecurityPolicyRelationsCallable(const Model::ListSecurityPolicyRelationsRequest& 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;
+			ListSystemSecurityPoliciesOutcome listSystemSecurityPolicies(const Model::ListSystemSecurityPoliciesRequest &request)const;
+			void listSystemSecurityPoliciesAsync(const Model::ListSystemSecurityPoliciesRequest& request, const ListSystemSecurityPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSystemSecurityPoliciesOutcomeCallable listSystemSecurityPoliciesCallable(const Model::ListSystemSecurityPoliciesRequest& request) const;
+			ListTagKeysOutcome listTagKeys(const Model::ListTagKeysRequest &request)const;
+			void listTagKeysAsync(const Model::ListTagKeysRequest& request, const ListTagKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTagKeysOutcomeCallable listTagKeysCallable(const Model::ListTagKeysRequest& 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;
+			ListTagValuesOutcome listTagValues(const Model::ListTagValuesRequest &request)const;
+			void listTagValuesAsync(const Model::ListTagValuesRequest& request, const ListTagValuesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTagValuesOutcomeCallable listTagValuesCallable(const Model::ListTagValuesRequest& 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;
+			RemoveEntriesFromAclOutcome removeEntriesFromAcl(const Model::RemoveEntriesFromAclRequest &request)const;
+			void removeEntriesFromAclAsync(const Model::RemoveEntriesFromAclRequest& request, const RemoveEntriesFromAclAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveEntriesFromAclOutcomeCallable removeEntriesFromAclCallable(const Model::RemoveEntriesFromAclRequest& 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;
+			ReplaceServersInServerGroupOutcome replaceServersInServerGroup(const Model::ReplaceServersInServerGroupRequest &request)const;
+			void replaceServersInServerGroupAsync(const Model::ReplaceServersInServerGroupRequest& request, const ReplaceServersInServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReplaceServersInServerGroupOutcomeCallable replaceServersInServerGroupCallable(const Model::ReplaceServersInServerGroupRequest& 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;
+			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;
+			UpdateAclAttributeOutcome updateAclAttribute(const Model::UpdateAclAttributeRequest &request)const;
+			void updateAclAttributeAsync(const Model::UpdateAclAttributeRequest& request, const UpdateAclAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateAclAttributeOutcomeCallable updateAclAttributeCallable(const Model::UpdateAclAttributeRequest& request) const;
+			UpdateHealthCheckTemplateAttributeOutcome updateHealthCheckTemplateAttribute(const Model::UpdateHealthCheckTemplateAttributeRequest &request)const;
+			void updateHealthCheckTemplateAttributeAsync(const Model::UpdateHealthCheckTemplateAttributeRequest& request, const UpdateHealthCheckTemplateAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateHealthCheckTemplateAttributeOutcomeCallable updateHealthCheckTemplateAttributeCallable(const Model::UpdateHealthCheckTemplateAttributeRequest& 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;
+			UpdateListenerLogConfigOutcome updateListenerLogConfig(const Model::UpdateListenerLogConfigRequest &request)const;
+			void updateListenerLogConfigAsync(const Model::UpdateListenerLogConfigRequest& request, const UpdateListenerLogConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateListenerLogConfigOutcomeCallable updateListenerLogConfigCallable(const Model::UpdateListenerLogConfigRequest& 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;
+			UpdateLoadBalancerEditionOutcome updateLoadBalancerEdition(const Model::UpdateLoadBalancerEditionRequest &request)const;
+			void updateLoadBalancerEditionAsync(const Model::UpdateLoadBalancerEditionRequest& request, const UpdateLoadBalancerEditionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateLoadBalancerEditionOutcomeCallable updateLoadBalancerEditionCallable(const Model::UpdateLoadBalancerEditionRequest& request) const;
+			UpdateRuleAttributeOutcome updateRuleAttribute(const Model::UpdateRuleAttributeRequest &request)const;
+			void updateRuleAttributeAsync(const Model::UpdateRuleAttributeRequest& request, const UpdateRuleAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateRuleAttributeOutcomeCallable updateRuleAttributeCallable(const Model::UpdateRuleAttributeRequest& request) const;
+			UpdateRulesAttributeOutcome updateRulesAttribute(const Model::UpdateRulesAttributeRequest &request)const;
+			void updateRulesAttributeAsync(const Model::UpdateRulesAttributeRequest& request, const UpdateRulesAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateRulesAttributeOutcomeCallable updateRulesAttributeCallable(const Model::UpdateRulesAttributeRequest& 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_ALB_ALBCLIENT_H_

alb/include/alibabacloud/alb/AlbExport.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_ALB_ALBEXPORT_H_
+#define ALIBABACLOUD_ALB_ALBEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_ALB_LIBRARY)
+#		define ALIBABACLOUD_ALB_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_ALB_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_ALB_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_ALB_ALBEXPORT_H_

alb/include/alibabacloud/alb/model/AddEntriesToAclRequest.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_ADDENTRIESTOACLREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_ADDENTRIESTOACLREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT AddEntriesToAclRequest : public RpcServiceRequest {
+public:
+	struct AclEntries {
+		std::string entry;
+		std::string description;
+	};
+	AddEntriesToAclRequest();
+	~AddEntriesToAclRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getAclId() const;
+	void setAclId(const std::string &aclId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::vector<AclEntries> getAclEntries() const;
+	void setAclEntries(const std::vector<AclEntries> &aclEntries);
+
+private:
+	std::string clientToken_;
+	std::string aclId_;
+	bool dryRun_;
+	std::vector<AclEntries> aclEntries_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_ADDENTRIESTOACLREQUEST_H_

alb/include/alibabacloud/alb/model/AddEntriesToAclResult.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_ALB_MODEL_ADDENTRIESTOACLRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_ADDENTRIESTOACLRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT AddEntriesToAclResult : public ServiceResult
+			{
+			public:
+
+
+				AddEntriesToAclResult();
+				explicit AddEntriesToAclResult(const std::string &payload);
+				~AddEntriesToAclResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_ADDENTRIESTOACLRESULT_H_

alb/include/alibabacloud/alb/model/AddServersToServerGroupRequest.h

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

alb/include/alibabacloud/alb/model/AddServersToServerGroupResult.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_ALB_MODEL_ADDSERVERSTOSERVERGROUPRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_ADDSERVERSTOSERVERGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT AddServersToServerGroupResult : public ServiceResult
+			{
+			public:
+
+
+				AddServersToServerGroupResult();
+				explicit AddServersToServerGroupResult(const std::string &payload);
+				~AddServersToServerGroupResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_ADDSERVERSTOSERVERGROUPRESULT_H_

alb/include/alibabacloud/alb/model/AssociateAclsWithListenerRequest.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_ALB_MODEL_ASSOCIATEACLSWITHLISTENERREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_ASSOCIATEACLSWITHLISTENERREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT AssociateAclsWithListenerRequest : public RpcServiceRequest {
+public:
+	AssociateAclsWithListenerRequest();
+	~AssociateAclsWithListenerRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::vector<std::string> getAclIds() const;
+	void setAclIds(const std::vector<std::string> &aclIds);
+	std::string getAclType() const;
+	void setAclType(const std::string &aclType);
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::vector<std::string> aclIds_;
+	std::string aclType_;
+	std::string listenerId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_ASSOCIATEACLSWITHLISTENERREQUEST_H_

alb/include/alibabacloud/alb/model/AssociateAclsWithListenerResult.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_ALB_MODEL_ASSOCIATEACLSWITHLISTENERRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_ASSOCIATEACLSWITHLISTENERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT AssociateAclsWithListenerResult : public ServiceResult
+			{
+			public:
+
+
+				AssociateAclsWithListenerResult();
+				explicit AssociateAclsWithListenerResult(const std::string &payload);
+				~AssociateAclsWithListenerResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_ASSOCIATEACLSWITHLISTENERRESULT_H_

alb/include/alibabacloud/alb/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_ALB_MODEL_ASSOCIATEADDITIONALCERTIFICATESWITHLISTENERREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_ASSOCIATEADDITIONALCERTIFICATESWITHLISTENERREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT AssociateAdditionalCertificatesWithListenerRequest : public RpcServiceRequest {
+public:
+	struct Certificates {
+		std::string certificateId;
+	};
+	AssociateAdditionalCertificatesWithListenerRequest();
+	~AssociateAdditionalCertificatesWithListenerRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::vector<Certificates> getCertificates() const;
+	void setCertificates(const std::vector<Certificates> &certificates);
+
+private:
+	std::string clientToken_;
+	std::string listenerId_;
+	bool dryRun_;
+	std::vector<Certificates> certificates_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_ASSOCIATEADDITIONALCERTIFICATESWITHLISTENERREQUEST_H_

alb/include/alibabacloud/alb/model/AssociateAdditionalCertificatesWithListenerResult.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_ALB_MODEL_ASSOCIATEADDITIONALCERTIFICATESWITHLISTENERRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_ASSOCIATEADDITIONALCERTIFICATESWITHLISTENERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT AssociateAdditionalCertificatesWithListenerResult : public ServiceResult
+			{
+			public:
+
+
+				AssociateAdditionalCertificatesWithListenerResult();
+				explicit AssociateAdditionalCertificatesWithListenerResult(const std::string &payload);
+				~AssociateAdditionalCertificatesWithListenerResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_ASSOCIATEADDITIONALCERTIFICATESWITHLISTENERRESULT_H_

alb/include/alibabacloud/alb/model/CreateAclRequest.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_ALB_MODEL_CREATEACLREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_CREATEACLREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT CreateAclRequest : public RpcServiceRequest {
+public:
+	CreateAclRequest();
+	~CreateAclRequest();
+	std::string getAclName() const;
+	void setAclName(const std::string &aclName);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getAddressIpVersion() const;
+	void setAddressIpVersion(const std::string &addressIpVersion);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string aclName_;
+	std::string clientToken_;
+	std::string addressIpVersion_;
+	std::string resourceGroupId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_CREATEACLREQUEST_H_

alb/include/alibabacloud/alb/model/CreateAclResult.h

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

alb/include/alibabacloud/alb/model/CreateHealthCheckTemplateRequest.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_ALB_MODEL_CREATEHEALTHCHECKTEMPLATEREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_CREATEHEALTHCHECKTEMPLATEREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT CreateHealthCheckTemplateRequest : public RpcServiceRequest {
+public:
+	CreateHealthCheckTemplateRequest();
+	~CreateHealthCheckTemplateRequest();
+	int getHealthCheckTimeout() const;
+	void setHealthCheckTimeout(int healthCheckTimeout);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getHealthCheckProtocol() const;
+	void setHealthCheckProtocol(const std::string &healthCheckProtocol);
+	int getUnhealthyThreshold() const;
+	void setUnhealthyThreshold(int unhealthyThreshold);
+	int getHealthyThreshold() const;
+	void setHealthyThreshold(int healthyThreshold);
+	bool getHealthCheckTcpFastCloseEnabled() const;
+	void setHealthCheckTcpFastCloseEnabled(bool healthCheckTcpFastCloseEnabled);
+	std::string getHealthCheckPath() const;
+	void setHealthCheckPath(const std::string &healthCheckPath);
+	std::vector<std::string> getHealthCheckCodes() const;
+	void setHealthCheckCodes(const std::vector<std::string> &healthCheckCodes);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getHealthCheckMethod() const;
+	void setHealthCheckMethod(const std::string &healthCheckMethod);
+	std::string getHealthCheckHost() const;
+	void setHealthCheckHost(const std::string &healthCheckHost);
+	int getHealthCheckInterval() const;
+	void setHealthCheckInterval(int healthCheckInterval);
+	std::string getHealthCheckTemplateName() const;
+	void setHealthCheckTemplateName(const std::string &healthCheckTemplateName);
+	std::vector<std::string> getHealthCheckHttpCodes() const;
+	void setHealthCheckHttpCodes(const std::vector<std::string> &healthCheckHttpCodes);
+	std::string getHealthCheckHttpVersion() const;
+	void setHealthCheckHttpVersion(const std::string &healthCheckHttpVersion);
+	int getHealthCheckConnectPort() const;
+	void setHealthCheckConnectPort(int healthCheckConnectPort);
+
+private:
+	int healthCheckTimeout_;
+	std::string clientToken_;
+	std::string healthCheckProtocol_;
+	int unhealthyThreshold_;
+	int healthyThreshold_;
+	bool healthCheckTcpFastCloseEnabled_;
+	std::string healthCheckPath_;
+	std::vector<std::string> healthCheckCodes_;
+	bool dryRun_;
+	std::string healthCheckMethod_;
+	std::string healthCheckHost_;
+	int healthCheckInterval_;
+	std::string healthCheckTemplateName_;
+	std::vector<std::string> healthCheckHttpCodes_;
+	std::string healthCheckHttpVersion_;
+	int healthCheckConnectPort_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_CREATEHEALTHCHECKTEMPLATEREQUEST_H_

alb/include/alibabacloud/alb/model/CreateHealthCheckTemplateResult.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_ALB_MODEL_CREATEHEALTHCHECKTEMPLATERESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_CREATEHEALTHCHECKTEMPLATERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT CreateHealthCheckTemplateResult : public ServiceResult
+			{
+			public:
+
+
+				CreateHealthCheckTemplateResult();
+				explicit CreateHealthCheckTemplateResult(const std::string &payload);
+				~CreateHealthCheckTemplateResult();
+				std::string getHealthCheckTemplateId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string healthCheckTemplateId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_CREATEHEALTHCHECKTEMPLATERESULT_H_

alb/include/alibabacloud/alb/model/CreateListenerRequest.h

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_CREATELISTENERREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_CREATELISTENERREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT CreateListenerRequest : public RpcServiceRequest {
+public:
+	struct QuicConfig {
+		bool quicUpgradeEnabled;
+		std::string quicListenerId;
+	};
+	struct DefaultActions {
+		struct ForwardGroupConfig {
+			struct ServerGroupTuplesItem {
+				std::string serverGroupId;
+			};
+			ServerGroupTuplesItem serverGroupTuplesItem;
+			std::vector<ServerGroupTuplesItem> serverGroupTuples;
+		};
+		ForwardGroupConfig forwardGroupConfig;
+		std::string type;
+	};
+	struct CaCertificates {
+		std::string certificateId;
+	};
+	struct XForwardedForConfig {
+		std::string xForwardedForClientCertSubjectDNAlias;
+		bool xForwardedForClientCertIssuerDNEnabled;
+		bool xForwardedForClientCertFingerprintEnabled;
+		std::string xForwardedForClientCertIssuerDNAlias;
+		bool xForwardedForProtoEnabled;
+		std::string xForwardedForClientCertFingerprintAlias;
+		bool xForwardedForClientCertClientVerifyEnabled;
+		bool xForwardedForSLBPortEnabled;
+		bool xForwardedForClientCertSubjectDNEnabled;
+		std::string xForwardedForClientCertClientVerifyAlias;
+		bool xForwardedForClientSrcPortEnabled;
+		bool xForwardedForEnabled;
+		bool xForwardedForSLBIdEnabled;
+	};
+	struct Certificates {
+		std::string certificateId;
+	};
+	CreateListenerRequest();
+	~CreateListenerRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getGzipEnabled() const;
+	void setGzipEnabled(bool gzipEnabled);
+	QuicConfig getQuicConfig() const;
+	void setQuicConfig(const QuicConfig &quicConfig);
+	bool getHttp2Enabled() const;
+	void setHttp2Enabled(bool http2Enabled);
+	std::vector<DefaultActions> getDefaultActions() const;
+	void setDefaultActions(const std::vector<DefaultActions> &defaultActions);
+	int getListenerPort() const;
+	void setListenerPort(int listenerPort);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	int getRequestTimeout() const;
+	void setRequestTimeout(int requestTimeout);
+	std::vector<CaCertificates> getCaCertificates() const;
+	void setCaCertificates(const std::vector<CaCertificates> &caCertificates);
+	XForwardedForConfig getXForwardedForConfig() const;
+	void setXForwardedForConfig(const XForwardedForConfig &xForwardedForConfig);
+	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::vector<Certificates> getCertificates() const;
+	void setCertificates(const std::vector<Certificates> &certificates);
+	std::string getListenerDescription() const;
+	void setListenerDescription(const std::string &listenerDescription);
+	bool getCaEnabled() const;
+	void setCaEnabled(bool caEnabled);
+
+private:
+	std::string clientToken_;
+	bool gzipEnabled_;
+	QuicConfig quicConfig_;
+	bool http2Enabled_;
+	std::vector<DefaultActions> defaultActions_;
+	int listenerPort_;
+	bool dryRun_;
+	int requestTimeout_;
+	std::vector<CaCertificates> caCertificates_;
+	XForwardedForConfig xForwardedForConfig_;
+	std::string listenerProtocol_;
+	std::string securityPolicyId_;
+	int idleTimeout_;
+	std::string loadBalancerId_;
+	std::vector<Certificates> certificates_;
+	std::string listenerDescription_;
+	bool caEnabled_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_CREATELISTENERREQUEST_H_

alb/include/alibabacloud/alb/model/CreateListenerResult.h

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

alb/include/alibabacloud/alb/model/CreateLoadBalancerRequest.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_CREATELOADBALANCERREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_CREATELOADBALANCERREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT CreateLoadBalancerRequest : public RpcServiceRequest {
+public:
+	struct ModificationProtectionConfig {
+		std::string reason;
+		std::string status;
+	};
+	struct LoadBalancerBillingConfig {
+		std::string internetChargeType;
+		int internetBandwidth;
+		std::string payType;
+	};
+	struct ZoneMappings {
+		std::string vSwitchId;
+		std::string zoneId;
+	};
+	CreateLoadBalancerRequest();
+	~CreateLoadBalancerRequest();
+	std::string getLoadBalancerEdition() const;
+	void setLoadBalancerEdition(const std::string &loadBalancerEdition);
+	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);
+	bool getDeletionProtectionEnabled() const;
+	void setDeletionProtectionEnabled(bool deletionProtectionEnabled);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getLoadBalancerName() const;
+	void setLoadBalancerName(const std::string &loadBalancerName);
+	std::string getAddressType() const;
+	void setAddressType(const std::string &addressType);
+	std::string getAddressAllocatedMode() const;
+	void setAddressAllocatedMode(const std::string &addressAllocatedMode);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::vector<ZoneMappings> getZoneMappings() const;
+	void setZoneMappings(const std::vector<ZoneMappings> &zoneMappings);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+
+private:
+	std::string loadBalancerEdition_;
+	std::string clientToken_;
+	ModificationProtectionConfig modificationProtectionConfig_;
+	LoadBalancerBillingConfig loadBalancerBillingConfig_;
+	bool deletionProtectionEnabled_;
+	std::string resourceGroupId_;
+	std::string loadBalancerName_;
+	std::string addressType_;
+	std::string addressAllocatedMode_;
+	bool dryRun_;
+	std::vector<ZoneMappings> zoneMappings_;
+	std::string vpcId_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_CREATELOADBALANCERREQUEST_H_

alb/include/alibabacloud/alb/model/CreateLoadBalancerResult.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_ALB_MODEL_CREATELOADBALANCERRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_CREATELOADBALANCERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT CreateLoadBalancerResult : public ServiceResult
+			{
+			public:
+
+
+				CreateLoadBalancerResult();
+				explicit CreateLoadBalancerResult(const std::string &payload);
+				~CreateLoadBalancerResult();
+				std::string getLoadBalancerId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string loadBalancerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_CREATELOADBALANCERRESULT_H_

alb/include/alibabacloud/alb/model/CreateRuleRequest.h

@@ -0,0 +1,187 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_CREATERULEREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_CREATERULEREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT CreateRuleRequest : public RpcServiceRequest {
+public:
+	struct RuleActions {
+		struct FixedResponseConfig {
+			std::string httpCode;
+			std::string content;
+			std::string contentType;
+		};
+		FixedResponseConfig fixedResponseConfig;
+		struct TrafficMirrorConfig {
+			struct MirrorGroupConfig {
+				struct ServerGroupTuplesItem {
+					std::string serverGroupId;
+				};
+				ServerGroupTuplesItem serverGroupTuplesItem;
+				std::vector<ServerGroupTuplesItem> serverGroupTuples;
+			};
+			MirrorGroupConfig mirrorGroupConfig;
+			std::string targetType;
+		};
+		TrafficMirrorConfig trafficMirrorConfig;
+		struct ForwardGroupConfig {
+			struct ServerGroupStickySession {
+				bool enabled;
+				int timeout;
+			};
+			ServerGroupStickySession serverGroupStickySession;
+			struct ServerGroupTuplesItem {
+				std::string serverGroupId;
+				int weight;
+			};
+			ServerGroupTuplesItem serverGroupTuplesItem;
+			std::vector<ServerGroupTuplesItem> serverGroupTuples;
+		};
+		ForwardGroupConfig forwardGroupConfig;
+		struct RemoveHeaderConfig {
+			std::string key;
+		};
+		RemoveHeaderConfig removeHeaderConfig;
+		struct InsertHeaderConfig {
+			std::string valueType;
+			bool coverEnabled;
+			std::string value;
+			std::string key;
+		};
+		InsertHeaderConfig insertHeaderConfig;
+		struct TrafficLimitConfig {
+			int qPS;
+		};
+		TrafficLimitConfig trafficLimitConfig;
+		struct RedirectConfig {
+			std::string path;
+			std::string protocol;
+			std::string port;
+			std::string query;
+			std::string host;
+			std::string httpCode;
+		};
+		RedirectConfig redirectConfig;
+		std::string type;
+		int order;
+		struct RewriteConfig {
+			std::string path;
+			std::string query;
+			std::string host;
+		};
+		RewriteConfig rewriteConfig;
+	};
+	struct RuleConditions {
+		struct MethodConfig {
+			std::string string;
+			std::vector<std::string> values;
+		};
+		MethodConfig methodConfig;
+		struct SourceIpConfig {
+			std::string string;
+			std::vector<std::string> values;
+		};
+		SourceIpConfig sourceIpConfig;
+		struct HostConfig {
+			std::string string;
+			std::vector<std::string> values;
+		};
+		HostConfig hostConfig;
+		struct QueryStringConfig {
+			struct ValuesItem {
+				std::string value;
+				std::string key;
+			};
+			ValuesItem valuesItem;
+			std::vector<ValuesItem> values;
+		};
+		QueryStringConfig queryStringConfig;
+		struct ResponseStatusCodeConfig {
+			std::string string;
+			std::vector<std::string> values;
+		};
+		ResponseStatusCodeConfig responseStatusCodeConfig;
+		struct PathConfig {
+			std::string string;
+			std::vector<std::string> values;
+		};
+		PathConfig pathConfig;
+		struct CookieConfig {
+			struct ValuesItem {
+				std::string value;
+				std::string key;
+			};
+			ValuesItem valuesItem;
+			std::vector<ValuesItem> values;
+		};
+		CookieConfig cookieConfig;
+		std::string type;
+		struct HeaderConfig {
+			std::string string;
+			std::vector<std::string> values;
+			std::string key;
+		};
+		HeaderConfig headerConfig;
+		struct ResponseHeaderConfig {
+			std::string string;
+			std::vector<std::string> values;
+			std::string key;
+		};
+		ResponseHeaderConfig responseHeaderConfig;
+	};
+	CreateRuleRequest();
+	~CreateRuleRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRuleName() const;
+	void setRuleName(const std::string &ruleName);
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	std::string getDirection() const;
+	void setDirection(const std::string &direction);
+	std::vector<RuleActions> getRuleActions() const;
+	void setRuleActions(const std::vector<RuleActions> &ruleActions);
+	std::vector<RuleConditions> getRuleConditions() const;
+	void setRuleConditions(const std::vector<RuleConditions> &ruleConditions);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	int getPriority() const;
+	void setPriority(int priority);
+
+private:
+	std::string clientToken_;
+	std::string ruleName_;
+	std::string listenerId_;
+	std::string direction_;
+	std::vector<RuleActions> ruleActions_;
+	std::vector<RuleConditions> ruleConditions_;
+	bool dryRun_;
+	int priority_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_CREATERULEREQUEST_H_

alb/include/alibabacloud/alb/model/CreateRuleResult.h

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

alb/include/alibabacloud/alb/model/CreateRulesRequest.h

@@ -0,0 +1,184 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_CREATERULESREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_CREATERULESREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT CreateRulesRequest : public RpcServiceRequest {
+public:
+	struct Rules {
+		struct RuleConditionsItem {
+			struct MethodConfig {
+				std::string string;
+				std::vector<std::string> values;
+			};
+			MethodConfig methodConfig;
+			struct SourceIpConfig {
+				std::string string;
+				std::vector<std::string> values;
+			};
+			SourceIpConfig sourceIpConfig;
+			struct HostConfig {
+				std::string string;
+				std::vector<std::string> values;
+			};
+			HostConfig hostConfig;
+			struct QueryStringConfig {
+				struct ValuesItem {
+					std::string value;
+					std::string key;
+				};
+				ValuesItem valuesItem;
+				std::vector<ValuesItem> values;
+			};
+			QueryStringConfig queryStringConfig;
+			struct ResponseStatusCodeConfig {
+				std::string string;
+				std::vector<std::string> values;
+			};
+			ResponseStatusCodeConfig responseStatusCodeConfig;
+			struct PathConfig {
+				std::string string;
+				std::vector<std::string> values;
+			};
+			PathConfig pathConfig;
+			struct CookieConfig {
+				struct ValuesItem {
+					std::string value;
+					std::string key;
+				};
+				ValuesItem valuesItem;
+				std::vector<ValuesItem> values;
+			};
+			CookieConfig cookieConfig;
+			std::string type;
+			struct HeaderConfig {
+				std::string string;
+				std::vector<std::string> values;
+				std::string key;
+			};
+			HeaderConfig headerConfig;
+			struct ResponseHeaderConfig {
+				std::string string;
+				std::vector<std::string> values;
+				std::string key;
+			};
+			ResponseHeaderConfig responseHeaderConfig;
+		};
+		RuleConditionsItem ruleConditionsItem;
+		std::vector<RuleConditionsItem> ruleConditions;
+		std::string ruleName;
+		int priority;
+		struct RuleActionsItem {
+			struct FixedResponseConfig {
+				std::string httpCode;
+				std::string content;
+				std::string contentType;
+			};
+			FixedResponseConfig fixedResponseConfig;
+			struct TrafficMirrorConfig {
+				struct MirrorGroupConfig {
+					struct ServerGroupTuplesItem {
+						std::string serverGroupId;
+					};
+					ServerGroupTuplesItem serverGroupTuplesItem;
+					std::vector<ServerGroupTuplesItem> serverGroupTuples;
+				};
+				MirrorGroupConfig mirrorGroupConfig;
+				std::string targetType;
+			};
+			TrafficMirrorConfig trafficMirrorConfig;
+			struct ForwardGroupConfig {
+				struct ServerGroupStickySession {
+					bool enabled;
+					int timeout;
+				};
+				ServerGroupStickySession serverGroupStickySession;
+				struct ServerGroupTuplesItem {
+					std::string serverGroupId;
+					int weight;
+				};
+				ServerGroupTuplesItem serverGroupTuplesItem;
+				std::vector<ServerGroupTuplesItem> serverGroupTuples;
+			};
+			ForwardGroupConfig forwardGroupConfig;
+			struct RemoveHeaderConfig {
+				std::string key;
+			};
+			RemoveHeaderConfig removeHeaderConfig;
+			struct InsertHeaderConfig {
+				std::string valueType;
+				bool coverEnabled;
+				std::string value;
+				std::string key;
+			};
+			InsertHeaderConfig insertHeaderConfig;
+			struct TrafficLimitConfig {
+				int qPS;
+			};
+			TrafficLimitConfig trafficLimitConfig;
+			struct RedirectConfig {
+				std::string path;
+				std::string protocol;
+				std::string port;
+				std::string query;
+				std::string host;
+				std::string httpCode;
+			};
+			RedirectConfig redirectConfig;
+			std::string type;
+			int order;
+			struct RewriteConfig {
+				std::string path;
+				std::string query;
+				std::string host;
+			};
+			RewriteConfig rewriteConfig;
+		};
+		RuleActionsItem ruleActionsItem;
+		std::vector<RuleActionsItem> ruleActions;
+		std::string direction;
+	};
+	CreateRulesRequest();
+	~CreateRulesRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::vector<Rules> getRules() const;
+	void setRules(const std::vector<Rules> &rules);
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::vector<Rules> rules_;
+	std::string listenerId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_CREATERULESREQUEST_H_

alb/include/alibabacloud/alb/model/CreateRulesResult.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_ALB_MODEL_CREATERULESRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_CREATERULESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT CreateRulesResult : public ServiceResult
+			{
+			public:
+				struct RuleId
+				{
+					int priority;
+					std::string ruleId;
+				};
+
+
+				CreateRulesResult();
+				explicit CreateRulesResult(const std::string &payload);
+				~CreateRulesResult();
+				std::vector<RuleId> getRuleIds()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<RuleId> ruleIds_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_CREATERULESRESULT_H_

alb/include/alibabacloud/alb/model/CreateSecurityPolicyRequest.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_ALB_MODEL_CREATESECURITYPOLICYREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_CREATESECURITYPOLICYREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT CreateSecurityPolicyRequest : public RpcServiceRequest {
+public:
+	CreateSecurityPolicyRequest();
+	~CreateSecurityPolicyRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	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);
+
+private:
+	std::string clientToken_;
+	std::string resourceGroupId_;
+	std::vector<std::string> ciphers_;
+	std::vector<std::string> tLSVersions_;
+	std::string securityPolicyName_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_CREATESECURITYPOLICYREQUEST_H_

alb/include/alibabacloud/alb/model/CreateSecurityPolicyResult.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_ALB_MODEL_CREATESECURITYPOLICYRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_CREATESECURITYPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT CreateSecurityPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				CreateSecurityPolicyResult();
+				explicit CreateSecurityPolicyResult(const std::string &payload);
+				~CreateSecurityPolicyResult();
+				std::string getSecurityPolicyId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string securityPolicyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_CREATESECURITYPOLICYRESULT_H_

alb/include/alibabacloud/alb/model/CreateServerGroupRequest.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_ALB_MODEL_CREATESERVERGROUPREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_CREATESERVERGROUPREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT CreateServerGroupRequest : public RpcServiceRequest {
+public:
+	struct HealthCheckConfig {
+		std::string string;
+		std::vector<std::string> healthCheckCodes;
+		bool healthCheckEnabled;
+		int healthCheckTimeout;
+		std::string healthCheckMethod;
+		std::string healthCheckHost;
+		std::string healthCheckProtocol;
+		int unhealthyThreshold;
+		int healthyThreshold;
+		bool healthCheckTcpFastCloseEnabled;
+		std::string healthCheckPath;
+		int healthCheckInterval;
+		std::string string;
+		std::vector<std::string> healthCheckHttpCodes;
+		std::string healthCheckHttpVersion;
+		int healthCheckConnectPort;
+	};
+	struct StickySessionConfig {
+		bool stickySessionEnabled;
+		std::string cookie;
+		int cookieTimeout;
+		std::string stickySessionType;
+	};
+	CreateServerGroupRequest();
+	~CreateServerGroupRequest();
+	std::string getServerGroupName() const;
+	void setServerGroupName(const std::string &serverGroupName);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	HealthCheckConfig getHealthCheckConfig() const;
+	void setHealthCheckConfig(const HealthCheckConfig &healthCheckConfig);
+	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);
+	StickySessionConfig getStickySessionConfig() const;
+	void setStickySessionConfig(const StickySessionConfig &stickySessionConfig);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getServerGroupType() const;
+	void setServerGroupType(const std::string &serverGroupType);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+
+private:
+	std::string serverGroupName_;
+	std::string clientToken_;
+	HealthCheckConfig healthCheckConfig_;
+	std::string scheduler_;
+	std::string resourceGroupId_;
+	std::string protocol_;
+	StickySessionConfig stickySessionConfig_;
+	bool dryRun_;
+	std::string serverGroupType_;
+	std::string vpcId_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_CREATESERVERGROUPREQUEST_H_

alb/include/alibabacloud/alb/model/CreateServerGroupResult.h

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

alb/include/alibabacloud/alb/model/DeleteAclRequest.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_ALB_MODEL_DELETEACLREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETEACLREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT DeleteAclRequest : public RpcServiceRequest {
+public:
+	DeleteAclRequest();
+	~DeleteAclRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getAclId() const;
+	void setAclId(const std::string &aclId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::string aclId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETEACLREQUEST_H_

alb/include/alibabacloud/alb/model/DeleteAclResult.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_ALB_MODEL_DELETEACLRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETEACLRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT DeleteAclResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteAclResult();
+				explicit DeleteAclResult(const std::string &payload);
+				~DeleteAclResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETEACLRESULT_H_

alb/include/alibabacloud/alb/model/DeleteHealthCheckTemplatesRequest.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_ALB_MODEL_DELETEHEALTHCHECKTEMPLATESREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETEHEALTHCHECKTEMPLATESREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT DeleteHealthCheckTemplatesRequest : public RpcServiceRequest {
+public:
+	DeleteHealthCheckTemplatesRequest();
+	~DeleteHealthCheckTemplatesRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::vector<std::string> getHealthCheckTemplateIds() const;
+	void setHealthCheckTemplateIds(const std::vector<std::string> &healthCheckTemplateIds);
+
+private:
+	std::string clientToken_;
+	bool dryRun_;
+	std::vector<std::string> healthCheckTemplateIds_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETEHEALTHCHECKTEMPLATESREQUEST_H_

alb/include/alibabacloud/alb/model/DeleteHealthCheckTemplatesResult.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_ALB_MODEL_DELETEHEALTHCHECKTEMPLATESRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETEHEALTHCHECKTEMPLATESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT DeleteHealthCheckTemplatesResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteHealthCheckTemplatesResult();
+				explicit DeleteHealthCheckTemplatesResult(const std::string &payload);
+				~DeleteHealthCheckTemplatesResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETEHEALTHCHECKTEMPLATESRESULT_H_

alb/include/alibabacloud/alb/model/DeleteListenerRequest.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_ALB_MODEL_DELETELISTENERREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETELISTENERREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_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);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::string listenerId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETELISTENERREQUEST_H_

alb/include/alibabacloud/alb/model/DeleteListenerResult.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_ALB_MODEL_DELETELISTENERRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETELISTENERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT DeleteListenerResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteListenerResult();
+				explicit DeleteListenerResult(const std::string &payload);
+				~DeleteListenerResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETELISTENERRESULT_H_

alb/include/alibabacloud/alb/model/DeleteLoadBalancerRequest.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_ALB_MODEL_DELETELOADBALANCERREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETELOADBALANCERREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT DeleteLoadBalancerRequest : public RpcServiceRequest {
+public:
+	DeleteLoadBalancerRequest();
+	~DeleteLoadBalancerRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	bool dryRun_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETELOADBALANCERREQUEST_H_

alb/include/alibabacloud/alb/model/DeleteLoadBalancerResult.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_ALB_MODEL_DELETELOADBALANCERRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETELOADBALANCERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT DeleteLoadBalancerResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteLoadBalancerResult();
+				explicit DeleteLoadBalancerResult(const std::string &payload);
+				~DeleteLoadBalancerResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETELOADBALANCERRESULT_H_

alb/include/alibabacloud/alb/model/DeleteRuleRequest.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_ALB_MODEL_DELETERULEREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETERULEREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT DeleteRuleRequest : public RpcServiceRequest {
+public:
+	DeleteRuleRequest();
+	~DeleteRuleRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getRuleId() const;
+	void setRuleId(const std::string &ruleId);
+
+private:
+	std::string clientToken_;
+	bool dryRun_;
+	std::string ruleId_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETERULEREQUEST_H_

alb/include/alibabacloud/alb/model/DeleteRuleResult.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_ALB_MODEL_DELETERULERESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETERULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT DeleteRuleResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteRuleResult();
+				explicit DeleteRuleResult(const std::string &payload);
+				~DeleteRuleResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETERULERESULT_H_

alb/include/alibabacloud/alb/model/DeleteRulesRequest.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_ALB_MODEL_DELETERULESREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETERULESREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT DeleteRulesRequest : public RpcServiceRequest {
+public:
+	DeleteRulesRequest();
+	~DeleteRulesRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::vector<std::string> getRuleIds() const;
+	void setRuleIds(const std::vector<std::string> &ruleIds);
+
+private:
+	std::string clientToken_;
+	bool dryRun_;
+	std::vector<std::string> ruleIds_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETERULESREQUEST_H_

alb/include/alibabacloud/alb/model/DeleteRulesResult.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_ALB_MODEL_DELETERULESRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETERULESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT DeleteRulesResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteRulesResult();
+				explicit DeleteRulesResult(const std::string &payload);
+				~DeleteRulesResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETERULESRESULT_H_

alb/include/alibabacloud/alb/model/DeleteSecurityPolicyRequest.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_ALB_MODEL_DELETESECURITYPOLICYREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETESECURITYPOLICYREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT DeleteSecurityPolicyRequest : public RpcServiceRequest {
+public:
+	DeleteSecurityPolicyRequest();
+	~DeleteSecurityPolicyRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getSecurityPolicyId() const;
+	void setSecurityPolicyId(const std::string &securityPolicyId);
+
+private:
+	std::string clientToken_;
+	bool dryRun_;
+	std::string securityPolicyId_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETESECURITYPOLICYREQUEST_H_

alb/include/alibabacloud/alb/model/DeleteSecurityPolicyResult.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_ALB_MODEL_DELETESECURITYPOLICYRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETESECURITYPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT DeleteSecurityPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteSecurityPolicyResult();
+				explicit DeleteSecurityPolicyResult(const std::string &payload);
+				~DeleteSecurityPolicyResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETESECURITYPOLICYRESULT_H_

alb/include/alibabacloud/alb/model/DeleteServerGroupRequest.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_ALB_MODEL_DELETESERVERGROUPREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETESERVERGROUPREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_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);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::string serverGroupId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETESERVERGROUPREQUEST_H_

alb/include/alibabacloud/alb/model/DeleteServerGroupResult.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_ALB_MODEL_DELETESERVERGROUPRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_DELETESERVERGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT DeleteServerGroupResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteServerGroupResult();
+				explicit DeleteServerGroupResult(const std::string &payload);
+				~DeleteServerGroupResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_DELETESERVERGROUPRESULT_H_

alb/include/alibabacloud/alb/model/DescribeRegionsRequest.h

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

alb/include/alibabacloud/alb/model/DescribeRegionsResult.h

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

alb/include/alibabacloud/alb/model/DescribeZonesRequest.h

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

alb/include/alibabacloud/alb/model/DescribeZonesResult.h

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

alb/include/alibabacloud/alb/model/DisableDeletionProtectionRequest.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_ALB_MODEL_DISABLEDELETIONPROTECTIONREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_DISABLEDELETIONPROTECTIONREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT DisableDeletionProtectionRequest : public RpcServiceRequest {
+public:
+	DisableDeletionProtectionRequest();
+	~DisableDeletionProtectionRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getResourceId() const;
+	void setResourceId(const std::string &resourceId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::string resourceId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_DISABLEDELETIONPROTECTIONREQUEST_H_

alb/include/alibabacloud/alb/model/DisableDeletionProtectionResult.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_ALB_MODEL_DISABLEDELETIONPROTECTIONRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_DISABLEDELETIONPROTECTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT DisableDeletionProtectionResult : public ServiceResult
+			{
+			public:
+
+
+				DisableDeletionProtectionResult();
+				explicit DisableDeletionProtectionResult(const std::string &payload);
+				~DisableDeletionProtectionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_DISABLEDELETIONPROTECTIONRESULT_H_

alb/include/alibabacloud/alb/model/DisableLoadBalancerAccessLogRequest.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_ALB_MODEL_DISABLELOADBALANCERACCESSLOGREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_DISABLELOADBALANCERACCESSLOGREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT DisableLoadBalancerAccessLogRequest : public RpcServiceRequest {
+public:
+	DisableLoadBalancerAccessLogRequest();
+	~DisableLoadBalancerAccessLogRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	bool dryRun_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_DISABLELOADBALANCERACCESSLOGREQUEST_H_

alb/include/alibabacloud/alb/model/DisableLoadBalancerAccessLogResult.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_ALB_MODEL_DISABLELOADBALANCERACCESSLOGRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_DISABLELOADBALANCERACCESSLOGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT DisableLoadBalancerAccessLogResult : public ServiceResult
+			{
+			public:
+
+
+				DisableLoadBalancerAccessLogResult();
+				explicit DisableLoadBalancerAccessLogResult(const std::string &payload);
+				~DisableLoadBalancerAccessLogResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_DISABLELOADBALANCERACCESSLOGRESULT_H_

alb/include/alibabacloud/alb/model/DissociateAclsFromListenerRequest.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_ALB_MODEL_DISSOCIATEACLSFROMLISTENERREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_DISSOCIATEACLSFROMLISTENERREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT DissociateAclsFromListenerRequest : public RpcServiceRequest {
+public:
+	DissociateAclsFromListenerRequest();
+	~DissociateAclsFromListenerRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::vector<std::string> getAclIds() const;
+	void setAclIds(const std::vector<std::string> &aclIds);
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::vector<std::string> aclIds_;
+	std::string listenerId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_DISSOCIATEACLSFROMLISTENERREQUEST_H_

alb/include/alibabacloud/alb/model/DissociateAclsFromListenerResult.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_ALB_MODEL_DISSOCIATEACLSFROMLISTENERRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_DISSOCIATEACLSFROMLISTENERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT DissociateAclsFromListenerResult : public ServiceResult
+			{
+			public:
+
+
+				DissociateAclsFromListenerResult();
+				explicit DissociateAclsFromListenerResult(const std::string &payload);
+				~DissociateAclsFromListenerResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_DISSOCIATEACLSFROMLISTENERRESULT_H_

alb/include/alibabacloud/alb/model/DissociateAdditionalCertificatesFromListenerRequest.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_ALB_MODEL_DISSOCIATEADDITIONALCERTIFICATESFROMLISTENERREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_DISSOCIATEADDITIONALCERTIFICATESFROMLISTENERREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT DissociateAdditionalCertificatesFromListenerRequest : public RpcServiceRequest {
+public:
+	struct Certificates {
+		std::string certificateId;
+	};
+	DissociateAdditionalCertificatesFromListenerRequest();
+	~DissociateAdditionalCertificatesFromListenerRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::vector<Certificates> getCertificates() const;
+	void setCertificates(const std::vector<Certificates> &certificates);
+
+private:
+	std::string clientToken_;
+	std::string listenerId_;
+	bool dryRun_;
+	std::vector<Certificates> certificates_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_DISSOCIATEADDITIONALCERTIFICATESFROMLISTENERREQUEST_H_

alb/include/alibabacloud/alb/model/DissociateAdditionalCertificatesFromListenerResult.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_ALB_MODEL_DISSOCIATEADDITIONALCERTIFICATESFROMLISTENERRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_DISSOCIATEADDITIONALCERTIFICATESFROMLISTENERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT DissociateAdditionalCertificatesFromListenerResult : public ServiceResult
+			{
+			public:
+
+
+				DissociateAdditionalCertificatesFromListenerResult();
+				explicit DissociateAdditionalCertificatesFromListenerResult(const std::string &payload);
+				~DissociateAdditionalCertificatesFromListenerResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_DISSOCIATEADDITIONALCERTIFICATESFROMLISTENERRESULT_H_

alb/include/alibabacloud/alb/model/EnableDeletionProtectionRequest.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_ALB_MODEL_ENABLEDELETIONPROTECTIONREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_ENABLEDELETIONPROTECTIONREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT EnableDeletionProtectionRequest : public RpcServiceRequest {
+public:
+	EnableDeletionProtectionRequest();
+	~EnableDeletionProtectionRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getResourceId() const;
+	void setResourceId(const std::string &resourceId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+
+private:
+	std::string clientToken_;
+	std::string resourceId_;
+	bool dryRun_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_ENABLEDELETIONPROTECTIONREQUEST_H_

alb/include/alibabacloud/alb/model/EnableDeletionProtectionResult.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_ALB_MODEL_ENABLEDELETIONPROTECTIONRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_ENABLEDELETIONPROTECTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT EnableDeletionProtectionResult : public ServiceResult
+			{
+			public:
+
+
+				EnableDeletionProtectionResult();
+				explicit EnableDeletionProtectionResult(const std::string &payload);
+				~EnableDeletionProtectionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_ENABLEDELETIONPROTECTIONRESULT_H_

alb/include/alibabacloud/alb/model/EnableLoadBalancerAccessLogRequest.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_ALB_MODEL_ENABLELOADBALANCERACCESSLOGREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_ENABLELOADBALANCERACCESSLOGREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT EnableLoadBalancerAccessLogRequest : public RpcServiceRequest {
+public:
+	EnableLoadBalancerAccessLogRequest();
+	~EnableLoadBalancerAccessLogRequest();
+	std::string getLogProject() const;
+	void setLogProject(const std::string &logProject);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+	std::string getLogStore() const;
+	void setLogStore(const std::string &logStore);
+
+private:
+	std::string logProject_;
+	std::string clientToken_;
+	bool dryRun_;
+	std::string loadBalancerId_;
+	std::string logStore_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_ENABLELOADBALANCERACCESSLOGREQUEST_H_

alb/include/alibabacloud/alb/model/EnableLoadBalancerAccessLogResult.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_ALB_MODEL_ENABLELOADBALANCERACCESSLOGRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_ENABLELOADBALANCERACCESSLOGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT EnableLoadBalancerAccessLogResult : public ServiceResult
+			{
+			public:
+
+
+				EnableLoadBalancerAccessLogResult();
+				explicit EnableLoadBalancerAccessLogResult(const std::string &payload);
+				~EnableLoadBalancerAccessLogResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_ENABLELOADBALANCERACCESSLOGRESULT_H_

alb/include/alibabacloud/alb/model/GetHealthCheckTemplateAttributeRequest.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_ALB_MODEL_GETHEALTHCHECKTEMPLATEATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_GETHEALTHCHECKTEMPLATEATTRIBUTEREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT GetHealthCheckTemplateAttributeRequest : public RpcServiceRequest {
+public:
+	GetHealthCheckTemplateAttributeRequest();
+	~GetHealthCheckTemplateAttributeRequest();
+	std::string getHealthCheckTemplateId() const;
+	void setHealthCheckTemplateId(const std::string &healthCheckTemplateId);
+
+private:
+	std::string healthCheckTemplateId_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_GETHEALTHCHECKTEMPLATEATTRIBUTEREQUEST_H_

alb/include/alibabacloud/alb/model/GetHealthCheckTemplateAttributeResult.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_GETHEALTHCHECKTEMPLATEATTRIBUTERESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_GETHEALTHCHECKTEMPLATEATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT GetHealthCheckTemplateAttributeResult : public ServiceResult
+			{
+			public:
+
+
+				GetHealthCheckTemplateAttributeResult();
+				explicit GetHealthCheckTemplateAttributeResult(const std::string &payload);
+				~GetHealthCheckTemplateAttributeResult();
+				std::string getHealthCheckTemplateId()const;
+				bool getServiceManagedEnabled()const;
+				int getHealthCheckInterval()const;
+				int getUnhealthyThreshold()const;
+				std::string getHealthCheckHost()const;
+				std::string getHealthCheckPath()const;
+				std::string getHealthCheckTemplateName()const;
+				std::string getHealthCheckHttpVersion()const;
+				int getHealthCheckTimeout()const;
+				bool getHealthCheckTcpFastCloseEnabled()const;
+				std::vector<std::string> getHealthCheckHttpCodes()const;
+				std::vector<std::string> getHealthCheckCodes()const;
+				int getHealthCheckConnectPort()const;
+				std::string getHealthCheckMethod()const;
+				int getHealthyThreshold()const;
+				std::string getServiceManagedMode()const;
+				std::string getHealthCheckProtocol()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string healthCheckTemplateId_;
+				bool serviceManagedEnabled_;
+				int healthCheckInterval_;
+				int unhealthyThreshold_;
+				std::string healthCheckHost_;
+				std::string healthCheckPath_;
+				std::string healthCheckTemplateName_;
+				std::string healthCheckHttpVersion_;
+				int healthCheckTimeout_;
+				bool healthCheckTcpFastCloseEnabled_;
+				std::vector<std::string> healthCheckHttpCodes_;
+				std::vector<std::string> healthCheckCodes_;
+				int healthCheckConnectPort_;
+				std::string healthCheckMethod_;
+				int healthyThreshold_;
+				std::string serviceManagedMode_;
+				std::string healthCheckProtocol_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_GETHEALTHCHECKTEMPLATEATTRIBUTERESULT_H_

alb/include/alibabacloud/alb/model/GetListenerAttributeRequest.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_ALB_MODEL_GETLISTENERATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_GETLISTENERATTRIBUTEREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT GetListenerAttributeRequest : public RpcServiceRequest {
+public:
+	GetListenerAttributeRequest();
+	~GetListenerAttributeRequest();
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+
+private:
+	std::string listenerId_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_GETLISTENERATTRIBUTEREQUEST_H_

alb/include/alibabacloud/alb/model/GetListenerAttributeResult.h

@@ -0,0 +1,156 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_GETLISTENERATTRIBUTERESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_GETLISTENERATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT GetListenerAttributeResult : public ServiceResult
+			{
+			public:
+				struct AclConfig
+				{
+					struct AclRelation
+					{
+						std::string status;
+						std::string aclId;
+					};
+					std::vector<AclRelation> aclRelations;
+					std::string aclType;
+				};
+				struct LogConfig
+				{
+					struct AccessLogTracingConfig
+					{
+						std::string tracingType;
+						int tracingSample;
+						bool tracingEnabled;
+					};
+					bool accessLogRecordCustomizedHeadersEnabled;
+					AccessLogTracingConfig accessLogTracingConfig;
+				};
+				struct QuicConfig
+				{
+					std::string quicListenerId;
+					bool quicUpgradeEnabled;
+				};
+				struct XForwardedForConfig
+				{
+					std::string xForwardedForClientCertFingerprintAlias;
+					bool xForwardedForClientCertFingerprintEnabled;
+					std::string xForwardedForClientCertIssuerDNAlias;
+					std::string xForwardedForClientCertClientVerifyAlias;
+					bool xForwardedForClientCertSubjectDNEnabled;
+					bool xForwardedForSLBIdEnabled;
+					std::string xForwardedForClientCertSubjectDNAlias;
+					bool xForwardedForProtoEnabled;
+					bool xForwardedForClientSrcPortEnabled;
+					bool xForwardedForEnabled;
+					bool xForwardedForSLBPortEnabled;
+					bool xForwardedForClientCertIssuerDNEnabled;
+					bool xForwardedForClientCertClientVerifyEnabled;
+				};
+				struct Certificate
+				{
+					std::string certificateId;
+				};
+				struct Certificate1
+				{
+					std::string status;
+					bool isDefault;
+					std::string certificateId;
+				};
+				struct DefaultAction
+				{
+					struct ForwardGroupConfig
+					{
+						struct ServerGroupTuple
+						{
+							std::string serverGroupId;
+						};
+						std::vector<ServerGroupTuple> serverGroupTuples;
+					};
+					std::string type;
+					ForwardGroupConfig forwardGroupConfig;
+				};
+
+
+				GetListenerAttributeResult();
+				explicit GetListenerAttributeResult(const std::string &payload);
+				~GetListenerAttributeResult();
+				bool getCaEnabled()const;
+				bool getServiceManagedEnabled()const;
+				int getListenerPort()const;
+				int getRequestTimeout()const;
+				bool getHttp2Enabled()const;
+				std::vector<DefaultAction> getDefaultActions()const;
+				std::vector<Certificate> getCertificates()const;
+				int getIdleTimeout()const;
+				std::string getLoadBalancerId()const;
+				QuicConfig getQuicConfig()const;
+				std::string getListenerProtocol()const;
+				bool getGzipEnabled()const;
+				std::string getListenerStatus()const;
+				std::string getSecurityPolicyId()const;
+				std::string getListenerDescription()const;
+				AclConfig getAclConfig()const;
+				std::string getServiceManagedMode()const;
+				XForwardedForConfig getXForwardedForConfig()const;
+				LogConfig getLogConfig()const;
+				std::vector<Certificate1> getCaCertificates()const;
+				std::string getListenerId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool caEnabled_;
+				bool serviceManagedEnabled_;
+				int listenerPort_;
+				int requestTimeout_;
+				bool http2Enabled_;
+				std::vector<DefaultAction> defaultActions_;
+				std::vector<Certificate> certificates_;
+				int idleTimeout_;
+				std::string loadBalancerId_;
+				QuicConfig quicConfig_;
+				std::string listenerProtocol_;
+				bool gzipEnabled_;
+				std::string listenerStatus_;
+				std::string securityPolicyId_;
+				std::string listenerDescription_;
+				AclConfig aclConfig_;
+				std::string serviceManagedMode_;
+				XForwardedForConfig xForwardedForConfig_;
+				LogConfig logConfig_;
+				std::vector<Certificate1> caCertificates_;
+				std::string listenerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_GETLISTENERATTRIBUTERESULT_H_

alb/include/alibabacloud/alb/model/GetLoadBalancerAttributeRequest.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_ALB_MODEL_GETLOADBALANCERATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_GETLOADBALANCERATTRIBUTEREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT GetLoadBalancerAttributeRequest : public RpcServiceRequest {
+public:
+	GetLoadBalancerAttributeRequest();
+	~GetLoadBalancerAttributeRequest();
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_GETLOADBALANCERATTRIBUTEREQUEST_H_

alb/include/alibabacloud/alb/model/GetLoadBalancerAttributeResult.h

@@ -0,0 +1,138 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_GETLOADBALANCERATTRIBUTERESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_GETLOADBALANCERATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT GetLoadBalancerAttributeResult : public ServiceResult
+			{
+			public:
+				struct AccessLogConfig
+				{
+					std::string logStore;
+					std::string logProject;
+				};
+				struct DeletionProtectionConfig
+				{
+					bool enabled;
+					std::string enabledTime;
+				};
+				struct LoadBalancerBillingConfig
+				{
+					int internetBandwidth;
+					std::string payType;
+					std::string internetChargeType;
+				};
+				struct ModificationProtectionConfig
+				{
+					std::string status;
+					std::string reason;
+				};
+				struct LoadBalancerOperationLock
+				{
+					std::string lockReason;
+					std::string lockType;
+				};
+				struct Tag
+				{
+					std::string value;
+					std::string key;
+				};
+				struct ZoneMapping
+				{
+					struct LoadBalancerAddress
+					{
+						std::string address;
+					};
+					std::string zoneId;
+					std::string vSwitchId;
+					std::vector<ZoneMapping::LoadBalancerAddress> loadBalancerAddresses;
+				};
+
+
+				GetLoadBalancerAttributeResult();
+				explicit GetLoadBalancerAttributeResult(const std::string &payload);
+				~GetLoadBalancerAttributeResult();
+				bool getServiceManagedEnabled()const;
+				std::string getLoadBalancerEdition()const;
+				std::string getResourceGroupId()const;
+				LoadBalancerBillingConfig getLoadBalancerBillingConfig()const;
+				std::vector<std::string> getFeatureLabels()const;
+				std::string getCreateTime()const;
+				std::string getLoadBalancerId()const;
+				std::vector<ZoneMapping> getZoneMappings()const;
+				std::string getDNSName()const;
+				ModificationProtectionConfig getModificationProtectionConfig()const;
+				std::string getLoadBalancerName()const;
+				AccessLogConfig getAccessLogConfig()const;
+				int getBandwidthCapacity()const;
+				DeletionProtectionConfig getDeletionProtectionConfig()const;
+				std::string getLoadBalancerBussinessStatus()const;
+				std::string getVpcId()const;
+				std::string getServiceManagedMode()const;
+				std::string getBandwidthPackageId()const;
+				std::string getRegionId()const;
+				std::string getAddressAllocatedMode()const;
+				std::string getAddressType()const;
+				std::string getLoadBalancerStatus()const;
+				std::vector<Tag> getTags()const;
+				std::vector<LoadBalancerOperationLock> getLoadBalancerOperationLocks()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool serviceManagedEnabled_;
+				std::string loadBalancerEdition_;
+				std::string resourceGroupId_;
+				LoadBalancerBillingConfig loadBalancerBillingConfig_;
+				std::vector<std::string> featureLabels_;
+				std::string createTime_;
+				std::string loadBalancerId_;
+				std::vector<ZoneMapping> zoneMappings_;
+				std::string dNSName_;
+				ModificationProtectionConfig modificationProtectionConfig_;
+				std::string loadBalancerName_;
+				AccessLogConfig accessLogConfig_;
+				int bandwidthCapacity_;
+				DeletionProtectionConfig deletionProtectionConfig_;
+				std::string loadBalancerBussinessStatus_;
+				std::string vpcId_;
+				std::string serviceManagedMode_;
+				std::string bandwidthPackageId_;
+				std::string regionId_;
+				std::string addressAllocatedMode_;
+				std::string addressType_;
+				std::string loadBalancerStatus_;
+				std::vector<Tag> tags_;
+				std::vector<LoadBalancerOperationLock> loadBalancerOperationLocks_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_GETLOADBALANCERATTRIBUTERESULT_H_

alb/include/alibabacloud/alb/model/ListAclEntriesRequest.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_ALB_MODEL_LISTACLENTRIESREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTACLENTRIESREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListAclEntriesRequest : public RpcServiceRequest {
+public:
+	ListAclEntriesRequest();
+	~ListAclEntriesRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getAclId() const;
+	void setAclId(const std::string &aclId);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+
+private:
+	std::string nextToken_;
+	std::string aclId_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTACLENTRIESREQUEST_H_

alb/include/alibabacloud/alb/model/ListAclEntriesResult.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_ALB_MODEL_LISTACLENTRIESRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTACLENTRIESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListAclEntriesResult : public ServiceResult
+			{
+			public:
+				struct AclEntry
+				{
+					std::string status;
+					std::string entry;
+					std::string description;
+				};
+
+
+				ListAclEntriesResult();
+				explicit ListAclEntriesResult(const std::string &payload);
+				~ListAclEntriesResult();
+				std::vector<AclEntry> getAclEntries()const;
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<AclEntry> aclEntries_;
+				int totalCount_;
+				std::string nextToken_;
+				int maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTACLENTRIESRESULT_H_

alb/include/alibabacloud/alb/model/ListAclRelationsRequest.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_ALB_MODEL_LISTACLRELATIONSREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTACLRELATIONSREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListAclRelationsRequest : public RpcServiceRequest {
+public:
+	ListAclRelationsRequest();
+	~ListAclRelationsRequest();
+	std::vector<std::string> getAclIds() const;
+	void setAclIds(const std::vector<std::string> &aclIds);
+
+private:
+	std::vector<std::string> aclIds_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTACLRELATIONSREQUEST_H_

alb/include/alibabacloud/alb/model/ListAclRelationsResult.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_ALB_MODEL_LISTACLRELATIONSRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTACLRELATIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListAclRelationsResult : public ServiceResult
+			{
+			public:
+				struct AclRelation
+				{
+					struct RelatedListener
+					{
+						std::string status;
+						int listenerPort;
+						std::string loadBalancerId;
+						std::string listenerProtocol;
+						std::string listenerId;
+					};
+					std::string aclId;
+					std::vector<AclRelation::RelatedListener> relatedListeners;
+				};
+
+
+				ListAclRelationsResult();
+				explicit ListAclRelationsResult(const std::string &payload);
+				~ListAclRelationsResult();
+				std::vector<AclRelation> getAclRelations()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<AclRelation> aclRelations_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTACLRELATIONSRESULT_H_

alb/include/alibabacloud/alb/model/ListAclsRequest.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_ALB_MODEL_LISTACLSREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTACLSREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListAclsRequest : public RpcServiceRequest {
+public:
+	ListAclsRequest();
+	~ListAclsRequest();
+	std::vector<std::string> getAclIds() const;
+	void setAclIds(const std::vector<std::string> &aclIds);
+	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::vector<std::string> getAclNames() const;
+	void setAclNames(const std::vector<std::string> &aclNames);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+
+private:
+	std::vector<std::string> aclIds_;
+	std::string addressIPVersion_;
+	std::string resourceGroupId_;
+	std::string nextToken_;
+	std::vector<std::string> aclNames_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTACLSREQUEST_H_

alb/include/alibabacloud/alb/model/ListAclsResult.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_ALB_MODEL_LISTACLSRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTACLSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListAclsResult : public ServiceResult
+			{
+			public:
+				struct Acl
+				{
+					bool serviceManagedEnabled;
+					std::string aclStatus;
+					std::string resourceGroupId;
+					std::string aclId;
+					std::string addressIPVersion;
+					std::string serviceManagedMode;
+					std::string aclName;
+				};
+
+
+				ListAclsResult();
+				explicit ListAclsResult(const std::string &payload);
+				~ListAclsResult();
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				std::vector<Acl> getAcls()const;
+				int getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string nextToken_;
+				std::vector<Acl> acls_;
+				int maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTACLSRESULT_H_

alb/include/alibabacloud/alb/model/ListAsynJobsRequest.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_ALB_MODEL_LISTASYNJOBSREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTASYNJOBSREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListAsynJobsRequest : public RpcServiceRequest {
+public:
+	ListAsynJobsRequest();
+	~ListAsynJobsRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	long getEndTime() const;
+	void setEndTime(long endTime);
+	long getBeginTime() const;
+	void setBeginTime(long beginTime);
+	std::string getResourceType() const;
+	void setResourceType(const std::string &resourceType);
+	std::string getApiName() const;
+	void setApiName(const std::string &apiName);
+	std::vector<std::string> getJobIds() const;
+	void setJobIds(const std::vector<std::string> &jobIds);
+	long getMaxResults() const;
+	void setMaxResults(long maxResults);
+	std::vector<std::string> getResourceIds() const;
+	void setResourceIds(const std::vector<std::string> &resourceIds);
+
+private:
+	std::string nextToken_;
+	long endTime_;
+	long beginTime_;
+	std::string resourceType_;
+	std::string apiName_;
+	std::vector<std::string> jobIds_;
+	long maxResults_;
+	std::vector<std::string> resourceIds_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTASYNJOBSREQUEST_H_

alb/include/alibabacloud/alb/model/ListAsynJobsResult.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_ALB_MODEL_LISTASYNJOBSRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTASYNJOBSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListAsynJobsResult : public ServiceResult
+			{
+			public:
+				struct Job
+				{
+					std::string status;
+					long modifyTime;
+					std::string apiName;
+					std::string resourceId;
+					long createTime;
+					std::string resourceType;
+					std::string errorCode;
+					std::string id;
+					std::string errorMessage;
+					std::string operateType;
+				};
+
+
+				ListAsynJobsResult();
+				explicit ListAsynJobsResult(const std::string &payload);
+				~ListAsynJobsResult();
+				long getTotalCount()const;
+				std::string getNextToken()const;
+				std::vector<Job> getJobs()const;
+				long getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				std::string nextToken_;
+				std::vector<Job> jobs_;
+				long maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTASYNJOBSRESULT_H_

alb/include/alibabacloud/alb/model/ListHealthCheckTemplatesRequest.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_ALB_MODEL_LISTHEALTHCHECKTEMPLATESREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTHEALTHCHECKTEMPLATESREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListHealthCheckTemplatesRequest : public RpcServiceRequest {
+public:
+	ListHealthCheckTemplatesRequest();
+	~ListHealthCheckTemplatesRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::vector<std::string> getHealthCheckTemplateNames() const;
+	void setHealthCheckTemplateNames(const std::vector<std::string> &healthCheckTemplateNames);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+	std::vector<std::string> getHealthCheckTemplateIds() const;
+	void setHealthCheckTemplateIds(const std::vector<std::string> &healthCheckTemplateIds);
+
+private:
+	std::string nextToken_;
+	std::vector<std::string> healthCheckTemplateNames_;
+	int maxResults_;
+	std::vector<std::string> healthCheckTemplateIds_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTHEALTHCHECKTEMPLATESREQUEST_H_

alb/include/alibabacloud/alb/model/ListHealthCheckTemplatesResult.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_LISTHEALTHCHECKTEMPLATESRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTHEALTHCHECKTEMPLATESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListHealthCheckTemplatesResult : public ServiceResult
+			{
+			public:
+				struct HealthCheckTemplate
+				{
+					std::string healthCheckTemplateId;
+					bool serviceManagedEnabled;
+					int healthCheckInterval;
+					int unhealthyThreshold;
+					std::string healthCheckHost;
+					std::string healthCheckPath;
+					std::string healthCheckTemplateName;
+					std::string healthCheckHttpVersion;
+					int healthCheckTimeout;
+					bool healthCheckTcpFastCloseEnabled;
+					int healthCheckConnectPort;
+					std::vector<std::string> healthCheckHttpCodes;
+					std::vector<std::string> healthCheckCodes;
+					std::string healthCheckMethod;
+					int healthyThreshold;
+					std::string serviceManagedMode;
+					std::string healthCheckProtocol;
+				};
+
+
+				ListHealthCheckTemplatesResult();
+				explicit ListHealthCheckTemplatesResult(const std::string &payload);
+				~ListHealthCheckTemplatesResult();
+				int getTotalCount()const;
+				std::vector<HealthCheckTemplate> getHealthCheckTemplates()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::vector<HealthCheckTemplate> healthCheckTemplates_;
+				std::string nextToken_;
+				int maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTHEALTHCHECKTEMPLATESRESULT_H_

alb/include/alibabacloud/alb/model/ListListenerCertificatesRequest.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_ALB_MODEL_LISTLISTENERCERTIFICATESREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTLISTENERCERTIFICATESREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListListenerCertificatesRequest : public RpcServiceRequest {
+public:
+	ListListenerCertificatesRequest();
+	~ListListenerCertificatesRequest();
+	std::string getCertificateType() const;
+	void setCertificateType(const std::string &certificateType);
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+
+private:
+	std::string certificateType_;
+	std::string listenerId_;
+	std::string nextToken_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTLISTENERCERTIFICATESREQUEST_H_

alb/include/alibabacloud/alb/model/ListListenerCertificatesResult.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_ALB_MODEL_LISTLISTENERCERTIFICATESRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTLISTENERCERTIFICATESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListListenerCertificatesResult : public ServiceResult
+			{
+			public:
+				struct CertificateModel
+				{
+					bool isDefault;
+					std::string status;
+					std::string certificateType;
+					std::string certificateId;
+				};
+
+
+				ListListenerCertificatesResult();
+				explicit ListListenerCertificatesResult(const std::string &payload);
+				~ListListenerCertificatesResult();
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				std::vector<CertificateModel> getCertificates()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string nextToken_;
+				int maxResults_;
+				std::vector<CertificateModel> certificates_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTLISTENERCERTIFICATESRESULT_H_

alb/include/alibabacloud/alb/model/ListListenersRequest.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_ALB_MODEL_LISTLISTENERSREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTLISTENERSREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListListenersRequest : public RpcServiceRequest {
+public:
+	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);
+	bool getAccessLogRecordCustomizedHeadersEnabled() const;
+	void setAccessLogRecordCustomizedHeadersEnabled(bool accessLogRecordCustomizedHeadersEnabled);
+	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_;
+	bool accessLogRecordCustomizedHeadersEnabled_;
+	std::string listenerProtocol_;
+	std::vector<std::string> listenerIds_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTLISTENERSREQUEST_H_

alb/include/alibabacloud/alb/model/ListListenersResult.h

@@ -0,0 +1,122 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_LISTLISTENERSRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTLISTENERSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListListenersResult : public ServiceResult
+			{
+			public:
+				struct Listener
+				{
+					struct LogConfig
+					{
+						struct AccessLogTracingConfig
+						{
+							std::string tracingType;
+							int tracingSample;
+							bool tracingEnabled;
+						};
+						bool accessLogRecordCustomizedHeadersEnabled;
+						AccessLogTracingConfig accessLogTracingConfig;
+					};
+					struct QuicConfig
+					{
+						std::string quicListenerId;
+						bool quicUpgradeEnabled;
+					};
+					struct XForwardedForConfig
+					{
+						std::string xForwardedForClientCertFingerprintAlias;
+						bool xForwardedForClientCertFingerprintEnabled;
+						std::string xForwardedForClientCertIssuerDNAlias;
+						std::string xForwardedForClientCertClientVerifyAlias;
+						bool xForwardedForClientCertSubjectDNEnabled;
+						bool xForwardedForSLBIdEnabled;
+						std::string xForwardedForClientCertSubjectDNAlias;
+						bool xForwardedForProtoEnabled;
+						bool xForwardedForClientSrcPortEnabled;
+						bool xForwardedForEnabled;
+						bool xForwardedForSLBPortEnabled;
+						bool xForwardedForClientCertIssuerDNEnabled;
+						bool xForwardedForClientCertClientVerifyEnabled;
+					};
+					struct DefaultAction
+					{
+						struct ForwardGroupConfig
+						{
+							struct ServerGroupTuple
+							{
+								std::string serverGroupId;
+							};
+							std::vector<ServerGroupTuple> serverGroupTuples;
+						};
+						std::string type;
+						ForwardGroupConfig forwardGroupConfig;
+					};
+					int listenerPort;
+					bool serviceManagedEnabled;
+					int requestTimeout;
+					bool http2Enabled;
+					std::vector<Listener::DefaultAction> defaultActions;
+					int idleTimeout;
+					std::string loadBalancerId;
+					QuicConfig quicConfig;
+					std::string listenerProtocol;
+					bool gzipEnabled;
+					std::string listenerStatus;
+					std::string securityPolicyId;
+					std::string listenerDescription;
+					std::string serviceManagedMode;
+					XForwardedForConfig xForwardedForConfig;
+					LogConfig logConfig;
+					std::string listenerId;
+				};
+
+
+				ListListenersResult();
+				explicit ListListenersResult(const std::string &payload);
+				~ListListenersResult();
+				std::vector<Listener> getListeners()const;
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Listener> listeners_;
+				int totalCount_;
+				std::string nextToken_;
+				int maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTLISTENERSRESULT_H_

alb/include/alibabacloud/alb/model/ListLoadBalancersRequest.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_LISTLOADBALANCERSREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTLOADBALANCERSREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListLoadBalancersRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
+	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 getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getLoadBalancerBussinessStatus() const;
+	void setLoadBalancerBussinessStatus(const std::string &loadBalancerBussinessStatus);
+	std::string getAddressType() const;
+	void setAddressType(const std::string &addressType);
+	std::vector<std::string> getVpcIds() const;
+	void setVpcIds(const std::vector<std::string> &vpcIds);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::string getAddress() const;
+	void setAddress(const std::string &address);
+	std::string getLoadBalancerStatus() const;
+	void setLoadBalancerStatus(const std::string &loadBalancerStatus);
+	std::string getInternetChargeType() const;
+	void setInternetChargeType(const std::string &internetChargeType);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	std::string getPayType() const;
+	void setPayType(const std::string &payType);
+
+private:
+	std::vector<std::string> loadBalancerNames_;
+	std::vector<std::string> loadBalancerIds_;
+	std::string resourceGroupId_;
+	std::string nextToken_;
+	std::string loadBalancerBussinessStatus_;
+	std::string addressType_;
+	std::vector<std::string> vpcIds_;
+	std::vector<Tag> tag_;
+	std::string address_;
+	std::string loadBalancerStatus_;
+	std::string internetChargeType_;
+	int maxResults_;
+	std::string zoneId_;
+	std::string payType_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTLOADBALANCERSREQUEST_H_

alb/include/alibabacloud/alb/model/ListLoadBalancersResult.h

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_LISTLOADBALANCERSRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTLOADBALANCERSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListLoadBalancersResult : public ServiceResult
+			{
+			public:
+				struct LoadBalancer
+				{
+					struct AccessLogConfig
+					{
+						std::string logStore;
+						std::string logProject;
+					};
+					struct DeletionProtectionConfig
+					{
+						bool enabled;
+						std::string enabledTime;
+					};
+					struct LoadBalancerBillingConfig
+					{
+						int internetBandwidth;
+						std::string payType;
+						std::string internetChargeType;
+					};
+					struct ModificationProtectionConfig
+					{
+						std::string status;
+						std::string reason;
+					};
+					struct LoadBalancerOperationLock
+					{
+						std::string lockReason;
+						std::string lockType;
+					};
+					struct Tag
+					{
+						std::string value;
+						std::string key;
+					};
+					bool serviceManagedEnabled;
+					std::string loadBalancerEdition;
+					std::string resourceGroupId;
+					LoadBalancerBillingConfig loadBalancerBillingConfig;
+					std::string createTime;
+					std::string loadBalancerId;
+					std::string dNSName;
+					ModificationProtectionConfig modificationProtectionConfig;
+					std::string loadBalancerName;
+					AccessLogConfig accessLogConfig;
+					int bandwidthCapacity;
+					DeletionProtectionConfig deletionProtectionConfig;
+					std::string loadBalancerBussinessStatus;
+					std::string vpcId;
+					std::string serviceManagedMode;
+					std::string bandwidthPackageId;
+					std::string addressAllocatedMode;
+					std::string addressType;
+					std::string loadBalancerStatus;
+					std::vector<LoadBalancer::Tag> tags;
+					std::vector<LoadBalancer::LoadBalancerOperationLock> loadBalancerOperationLocks;
+				};
+
+
+				ListLoadBalancersResult();
+				explicit ListLoadBalancersResult(const std::string &payload);
+				~ListLoadBalancersResult();
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				std::vector<LoadBalancer> getLoadBalancers()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string nextToken_;
+				int maxResults_;
+				std::vector<LoadBalancer> loadBalancers_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTLOADBALANCERSRESULT_H_

alb/include/alibabacloud/alb/model/ListRulesRequest.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_ALB_MODEL_LISTRULESREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTRULESREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListRulesRequest : public RpcServiceRequest {
+public:
+	ListRulesRequest();
+	~ListRulesRequest();
+	std::vector<std::string> getLoadBalancerIds() const;
+	void setLoadBalancerIds(const std::vector<std::string> &loadBalancerIds);
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getDirection() const;
+	void setDirection(const std::string &direction);
+	std::vector<std::string> getRuleIds() const;
+	void setRuleIds(const std::vector<std::string> &ruleIds);
+	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 listenerId_;
+	std::string nextToken_;
+	std::string direction_;
+	std::vector<std::string> ruleIds_;
+	std::vector<std::string> listenerIds_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTRULESREQUEST_H_

alb/include/alibabacloud/alb/model/ListRulesResult.h

@@ -0,0 +1,210 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_LISTRULESRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTRULESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListRulesResult : public ServiceResult
+			{
+			public:
+				struct Rule
+				{
+					struct Action
+					{
+						struct FixedResponseConfig
+						{
+							std::string httpCode;
+							std::string contentType;
+							std::string content;
+						};
+						struct ForwardGroupConfig
+						{
+							struct ServerGroupStickySession
+							{
+								int timeout;
+								bool enabled;
+							};
+							struct ServerGroupTuple
+							{
+								std::string serverGroupId;
+								int weight;
+							};
+							ServerGroupStickySession serverGroupStickySession;
+							std::vector<ServerGroupTuple> serverGroupTuples;
+						};
+						struct InsertHeaderConfig
+						{
+							bool coverEnabled;
+							std::string valueType;
+							std::string value;
+							std::string key;
+						};
+						struct RedirectConfig
+						{
+							std::string path;
+							std::string httpCode;
+							std::string query;
+							std::string port;
+							std::string host;
+							std::string protocol;
+						};
+						struct RemoveHeaderConfig
+						{
+							std::string key;
+						};
+						struct RewriteConfig
+						{
+							std::string path;
+							std::string query;
+							std::string host;
+						};
+						struct TrafficMirrorConfig
+						{
+							struct MirrorGroupConfig
+							{
+								struct ServerGroupTuple2
+								{
+									std::string serverGroupId;
+									int weight;
+								};
+								std::vector<ServerGroupTuple2> serverGroupTuples1;
+							};
+							MirrorGroupConfig mirrorGroupConfig;
+							std::string targetType;
+						};
+						struct TrafficLimitConfig
+						{
+							int qPS;
+						};
+						int order;
+						FixedResponseConfig fixedResponseConfig;
+						std::string type;
+						RedirectConfig redirectConfig;
+						ForwardGroupConfig forwardGroupConfig;
+						RemoveHeaderConfig removeHeaderConfig;
+						InsertHeaderConfig insertHeaderConfig;
+						RewriteConfig rewriteConfig;
+						TrafficLimitConfig trafficLimitConfig;
+						TrafficMirrorConfig trafficMirrorConfig;
+					};
+					struct Condition
+					{
+						struct CookieConfig
+						{
+							struct Value
+							{
+								std::string value;
+								std::string key;
+							};
+							std::vector<Value> values;
+						};
+						struct HeaderConfig
+						{
+							std::vector<std::string> values3;
+							std::string key;
+						};
+						struct HostConfig
+						{
+							std::vector<std::string> values4;
+						};
+						struct MethodConfig
+						{
+							std::vector<std::string> values5;
+						};
+						struct PathConfig
+						{
+							std::vector<std::string> values6;
+						};
+						struct QueryStringConfig
+						{
+							struct Value8
+							{
+								std::string value;
+								std::string key;
+							};
+							std::vector<Value8> values7;
+						};
+						struct SourceIpConfig
+						{
+							std::vector<std::string> values9;
+						};
+						struct ResponseStatusCodeConfig
+						{
+							std::vector<std::string> values10;
+						};
+						struct ResponseHeaderConfig
+						{
+							std::string key;
+							std::vector<std::string> values11;
+						};
+						MethodConfig methodConfig;
+						PathConfig pathConfig;
+						std::string type;
+						ResponseHeaderConfig responseHeaderConfig;
+						HostConfig hostConfig;
+						QueryStringConfig queryStringConfig;
+						CookieConfig cookieConfig;
+						ResponseStatusCodeConfig responseStatusCodeConfig;
+						HeaderConfig headerConfig;
+						SourceIpConfig sourceIpConfig;
+					};
+					std::vector<Rule::Action> ruleActions;
+					bool serviceManagedEnabled;
+					int priority;
+					std::string ruleId;
+					std::string serviceManagedMode;
+					std::vector<Rule::Condition> ruleConditions;
+					std::string loadBalancerId;
+					std::string ruleStatus;
+					std::string direction;
+					std::string ruleName;
+					std::string listenerId;
+				};
+
+
+				ListRulesResult();
+				explicit ListRulesResult(const std::string &payload);
+				~ListRulesResult();
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				std::vector<Rule> getRules()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string nextToken_;
+				int maxResults_;
+				std::vector<Rule> rules_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTRULESRESULT_H_

alb/include/alibabacloud/alb/model/ListSecurityPoliciesRequest.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_ALB_MODEL_LISTSECURITYPOLICIESREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTSECURITYPOLICIESREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListSecurityPoliciesRequest : public RpcServiceRequest {
+public:
+	ListSecurityPoliciesRequest();
+	~ListSecurityPoliciesRequest();
+	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::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::vector<std::string> securityPolicyIds_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTSECURITYPOLICIESREQUEST_H_

alb/include/alibabacloud/alb/model/ListSecurityPoliciesResult.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_ALB_MODEL_LISTSECURITYPOLICIESRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTSECURITYPOLICIESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListSecurityPoliciesResult : public ServiceResult
+			{
+			public:
+				struct SecurityPolicy
+				{
+					bool serviceManagedEnabled;
+					std::vector<std::string> ciphers;
+					std::string securityPolicyId;
+					std::string resourceGroupId;
+					std::string securityPolicyStatus;
+					std::string serviceManagedMode;
+					std::vector<std::string> tLSVersions;
+					std::string securityPolicyName;
+				};
+
+
+				ListSecurityPoliciesResult();
+				explicit ListSecurityPoliciesResult(const std::string &payload);
+				~ListSecurityPoliciesResult();
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				std::vector<SecurityPolicy> getSecurityPolicies()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string nextToken_;
+				int maxResults_;
+				std::vector<SecurityPolicy> securityPolicies_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTSECURITYPOLICIESRESULT_H_

alb/include/alibabacloud/alb/model/ListSecurityPolicyRelationsRequest.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_ALB_MODEL_LISTSECURITYPOLICYRELATIONSREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTSECURITYPOLICYRELATIONSREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListSecurityPolicyRelationsRequest : public RpcServiceRequest {
+public:
+	ListSecurityPolicyRelationsRequest();
+	~ListSecurityPolicyRelationsRequest();
+	std::vector<std::string> getSecurityPolicyIds() const;
+	void setSecurityPolicyIds(const std::vector<std::string> &securityPolicyIds);
+
+private:
+	std::vector<std::string> securityPolicyIds_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTSECURITYPOLICYRELATIONSREQUEST_H_

alb/include/alibabacloud/alb/model/ListSecurityPolicyRelationsResult.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_ALB_MODEL_LISTSECURITYPOLICYRELATIONSRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTSECURITYPOLICYRELATIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListSecurityPolicyRelationsResult : public ServiceResult
+			{
+			public:
+				struct SecrityPolicyRelation
+				{
+					struct RelatedListener
+					{
+						long listenerPort;
+						std::string loadBalancerId;
+						std::string listenerProtocol;
+						std::string listenerId;
+					};
+					std::string securityPolicyId;
+					std::vector<SecrityPolicyRelation::RelatedListener> relatedListeners;
+				};
+
+
+				ListSecurityPolicyRelationsResult();
+				explicit ListSecurityPolicyRelationsResult(const std::string &payload);
+				~ListSecurityPolicyRelationsResult();
+				std::vector<SecrityPolicyRelation> getSecrityPolicyRelations()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<SecrityPolicyRelation> secrityPolicyRelations_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTSECURITYPOLICYRELATIONSRESULT_H_

alb/include/alibabacloud/alb/model/ListServerGroupServersRequest.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_ALB_MODEL_LISTSERVERGROUPSERVERSREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTSERVERGROUPSERVERSREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListServerGroupServersRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
+	ListServerGroupServersRequest();
+	~ListServerGroupServersRequest();
+	std::string getServerGroupId() const;
+	void setServerGroupId(const std::string &serverGroupId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getServerIp() const;
+	void setServerIp(const std::string &serverIp);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::string getServerId() const;
+	void setServerId(const std::string &serverId);
+	std::vector<std::string> getServerIds() const;
+	void setServerIds(const std::vector<std::string> &serverIds);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+
+private:
+	std::string serverGroupId_;
+	std::string nextToken_;
+	std::string serverIp_;
+	std::vector<Tag> tag_;
+	std::string serverId_;
+	std::vector<std::string> serverIds_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTSERVERGROUPSERVERSREQUEST_H_

alb/include/alibabacloud/alb/model/ListServerGroupServersResult.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_ALB_MODEL_LISTSERVERGROUPSERVERSRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTSERVERGROUPSERVERSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListServerGroupServersResult : public ServiceResult
+			{
+			public:
+				struct BackendServer
+				{
+					std::string status;
+					std::string serverType;
+					std::string description;
+					std::string serverId;
+					int port;
+					std::string serverIp;
+					std::string serverGroupId;
+					int weight;
+				};
+
+
+				ListServerGroupServersResult();
+				explicit ListServerGroupServersResult(const std::string &payload);
+				~ListServerGroupServersResult();
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				std::vector<BackendServer> getServers()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string nextToken_;
+				int maxResults_;
+				std::vector<BackendServer> servers_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTSERVERGROUPSERVERSRESULT_H_

alb/include/alibabacloud/alb/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_ALB_MODEL_LISTSERVERGROUPSREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTSERVERGROUPSREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListServerGroupsRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
+	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::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	bool getShowRelationEnabled() const;
+	void setShowRelationEnabled(bool showRelationEnabled);
+	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::vector<Tag> tag_;
+	bool showRelationEnabled_;
+	std::vector<std::string> serverGroupIds_;
+	std::string serverGroupType_;
+	std::string vpcId_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTSERVERGROUPSREQUEST_H_

alb/include/alibabacloud/alb/model/ListServerGroupsResult.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_LISTSERVERGROUPSRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTSERVERGROUPSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListServerGroupsResult : public ServiceResult
+			{
+			public:
+				struct ServerGroup
+				{
+					struct HealthCheckConfig
+					{
+						int healthCheckInterval;
+						int unhealthyThreshold;
+						std::string healthCheckHost;
+						std::string healthCheckPath;
+						std::string healthCheckHttpVersion;
+						bool healthCheckEnabled;
+						int healthCheckTimeout;
+						bool healthCheckTcpFastCloseEnabled;
+						int healthCheckConnectPort;
+						std::vector<std::string> healthCheckHttpCodes;
+						std::vector<std::string> healthCheckCodes;
+						std::string healthCheckMethod;
+						int healthyThreshold;
+						std::string healthCheckProtocol;
+					};
+					struct StickySessionConfig
+					{
+						std::string cookie;
+						int cookieTimeout;
+						std::string stickySessionType;
+						bool stickySessionEnabled;
+					};
+					struct Tag
+					{
+						std::string value;
+						std::string key;
+					};
+					bool serviceManagedEnabled;
+					std::vector<std::string> relatedLoadBalancerIds;
+					std::string resourceGroupId;
+					std::string scheduler;
+					StickySessionConfig stickySessionConfig;
+					std::string serverGroupId;
+					std::string serverGroupType;
+					std::string serverGroupStatus;
+					std::string vpcId;
+					std::string serviceManagedMode;
+					HealthCheckConfig healthCheckConfig;
+					std::string protocol;
+					std::vector<ServerGroup::Tag> tags;
+					std::string serverGroupName;
+				};
+
+
+				ListServerGroupsResult();
+				explicit ListServerGroupsResult(const std::string &payload);
+				~ListServerGroupsResult();
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				std::vector<ServerGroup> getServerGroups()const;
+				int getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string nextToken_;
+				std::vector<ServerGroup> serverGroups_;
+				int maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTSERVERGROUPSRESULT_H_

alb/include/alibabacloud/alb/model/ListSystemSecurityPoliciesRequest.h

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

alb/include/alibabacloud/alb/model/ListSystemSecurityPoliciesResult.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_ALB_MODEL_LISTSYSTEMSECURITYPOLICIESRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTSYSTEMSECURITYPOLICIESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListSystemSecurityPoliciesResult : public ServiceResult
+			{
+			public:
+				struct SecurityPolicy
+				{
+					std::vector<std::string> ciphers;
+					std::string securityPolicyId;
+					std::vector<std::string> tLSVersions;
+				};
+
+
+				ListSystemSecurityPoliciesResult();
+				explicit ListSystemSecurityPoliciesResult(const std::string &payload);
+				~ListSystemSecurityPoliciesResult();
+				std::vector<SecurityPolicy> getSecurityPolicies()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<SecurityPolicy> securityPolicies_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTSYSTEMSECURITYPOLICIESRESULT_H_

alb/include/alibabacloud/alb/model/ListTagKeysRequest.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_ALB_MODEL_LISTTAGKEYSREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTTAGKEYSREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListTagKeysRequest : public RpcServiceRequest {
+public:
+	ListTagKeysRequest();
+	~ListTagKeysRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getKeyword() const;
+	void setKeyword(const std::string &keyword);
+	std::string getResourceType() const;
+	void setResourceType(const std::string &resourceType);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+	std::string getCategory() const;
+	void setCategory(const std::string &category);
+
+private:
+	std::string nextToken_;
+	std::string keyword_;
+	std::string resourceType_;
+	int maxResults_;
+	std::string category_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTTAGKEYSREQUEST_H_

alb/include/alibabacloud/alb/model/ListTagKeysResult.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_ALB_MODEL_LISTTAGKEYSRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTTAGKEYSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListTagKeysResult : public ServiceResult
+			{
+			public:
+				struct TagKey
+				{
+					std::string category;
+					std::string tagKey;
+				};
+
+
+				ListTagKeysResult();
+				explicit ListTagKeysResult(const std::string &payload);
+				~ListTagKeysResult();
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				std::vector<TagKey> getTagKeys()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string nextToken_;
+				int maxResults_;
+				std::vector<TagKey> tagKeys_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTTAGKEYSRESULT_H_

alb/include/alibabacloud/alb/model/ListTagResourcesRequest.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_ALB_MODEL_LISTTAGRESOURCESREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTTAGRESOURCESREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListTagResourcesRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
+	ListTagResourcesRequest();
+	~ListTagResourcesRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	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);
+
+private:
+	std::string nextToken_;
+	std::vector<Tag> tag_;
+	std::vector<std::string> resourceId_;
+	std::string resourceType_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTTAGRESOURCESREQUEST_H_

alb/include/alibabacloud/alb/model/ListTagResourcesResult.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_ALB_MODEL_LISTTAGRESOURCESRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTTAGRESOURCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ListTagResourcesResult : public ServiceResult
+			{
+			public:
+				struct TagResource
+				{
+					std::string resourceId;
+					std::string tagKey;
+					std::string resourceType;
+					std::string tagValue;
+				};
+
+
+				ListTagResourcesResult();
+				explicit ListTagResourcesResult(const std::string &payload);
+				~ListTagResourcesResult();
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				std::vector<TagResource> getTagResources()const;
+				int getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string nextToken_;
+				std::vector<TagResource> tagResources_;
+				int maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTTAGRESOURCESRESULT_H_

alb/include/alibabacloud/alb/model/ListTagValuesRequest.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_ALB_MODEL_LISTTAGVALUESREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_LISTTAGVALUESREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ListTagValuesRequest : public RpcServiceRequest {
+public:
+	ListTagValuesRequest();
+	~ListTagValuesRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getResourceId() const;
+	void setResourceId(const std::string &resourceId);
+	std::string getResourceType() const;
+	void setResourceType(const std::string &resourceType);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+	std::string getTagKey() const;
+	void setTagKey(const std::string &tagKey);
+
+private:
+	std::string nextToken_;
+	std::string resourceId_;
+	std::string resourceType_;
+	int maxResults_;
+	std::string tagKey_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_LISTTAGVALUESREQUEST_H_